def _read(self):
self._raw__raw_x = self._io.read_bytes(2)
self._raw_x = KaitaiStream.process_xor_many(self._raw__raw_x,
b"\x32\xB3")
io = KaitaiStream(BytesIO(self._raw_x))
self.x = Encrypted(u"xoru2", io)
self._raw__raw_y = self._io.read_bytes(2)
self._raw_y = KaitaiStream.process_xor_many(self._raw__raw_y,
b"\xB2\x28")
io = KaitaiStream(BytesIO(self._raw_y))
self.y = Encrypted(u"xoru2", io)
def _read(self):
self.list_ptr = FilePtr(self._io)
self._raw__raw_size = self._io.read_bytes(8)
self._raw_size = KaitaiStream.process_xor_many(
self._raw__raw_size, self.key)
io = KaitaiStream(BytesIO(self._raw_size))
self.size = Encrypted(u"xoru8", io)
def _read(self):
self.bonus_effect = StatsTuple(self._io)
self._raw__raw_element = self._io.read_bytes(1)
self._raw_element = KaitaiStream.process_xor_many(
self._raw__raw_element, b"\x05")
io = KaitaiStream(BytesIO(self._raw_element))
self.element = LegendaryElement(io)
self.padding = self._io.read_bytes(7)
def _read(self):
self.id = CryptString(u"ID", self._io)
self._raw__raw_width = self._io.read_bytes(4)
self._raw_width = KaitaiStream.process_xor_many(self._raw__raw_width, b"\x5F\xD7\x7C\x6B")
io = KaitaiStream(BytesIO(self._raw_width))
self.width = Encrypted(u"xoru4", io)
self._raw__raw_height = self._io.read_bytes(4)
self._raw_height = KaitaiStream.process_xor_many(self._raw__raw_height, b"\xD5\x12\xAA\x2B")
io = KaitaiStream(BytesIO(self._raw_height))
self.height = Encrypted(u"xoru4", io)
self._raw__raw_base_terrain = self._io.read_bytes(1)
self._raw_base_terrain = KaitaiStream.process_xor_many(self._raw__raw_base_terrain, b"\x41")
io = KaitaiStream(BytesIO(self._raw_base_terrain))
self.base_terrain = Encrypted(u"xoru1", io)
self.padding = self._io.read_bytes(7)
self._raw_terrain = self._io.read_bytes((self.height.data * self.width.data))
self.terrain = KaitaiStream.process_xor_many(self._raw_terrain, b"\xA1")
def _read(self):
self.unknown1 = self._io.read_u4le()
self._raw__raw_highest_score = self._io.read_bytes(4)
self._raw_highest_score = KaitaiStream.process_xor_many(self._raw__raw_highest_score, b"\xB1\x50\xE2\xA9")
io = KaitaiStream(BytesIO(self._raw_highest_score))
self.highest_score = Encrypted(u"xoru4", io)
self.field_ptr = FilePtr(self._io)
self.player_pos_ptr = FilePtr(self._io)
self.units_ptr = FilePtr(self._io)
self._raw__raw_player_count = self._io.read_bytes(4)
self._raw_player_count = KaitaiStream.process_xor_many(self._raw__raw_player_count, b"\x9A\xC7\x63\x9D")
io = KaitaiStream(BytesIO(self._raw_player_count))
self.player_count = Encrypted(u"xoru4", io)
self._raw__raw_unit_count = self._io.read_bytes(4)
self._raw_unit_count = KaitaiStream.process_xor_many(self._raw__raw_unit_count, b"\xEE\x10\x67\xAC")
io = KaitaiStream(BytesIO(self._raw_unit_count))
self.unit_count = Encrypted(u"xoru4", io)
self._raw__raw_turns_to_win = self._io.read_bytes(1)
self._raw_turns_to_win = KaitaiStream.process_xor_many(self._raw__raw_turns_to_win, b"\xFD")
io = KaitaiStream(BytesIO(self._raw_turns_to_win))
self.turns_to_win = Encrypted(u"xoru1", io)
self._raw__raw_last_enemy_phase = self._io.read_bytes(1)
self._raw_last_enemy_phase = KaitaiStream.process_xor_many(self._raw__raw_last_enemy_phase, b"\xC7")
io = KaitaiStream(BytesIO(self._raw_last_enemy_phase))
self.last_enemy_phase = Xorb1(io)
self._raw__raw_turns_to_defend = self._io.read_bytes(1)
self._raw_turns_to_defend = KaitaiStream.process_xor_many(self._raw__raw_turns_to_defend, b"\xEC")
io = KaitaiStream(BytesIO(self._raw_turns_to_defend))
self.turns_to_defend = Encrypted(u"xoru1", io)
def _read(self):
self._raw__raw_hp = self._io.read_bytes(2)
self._raw_hp = KaitaiStream.process_xor_many(self._raw__raw_hp, b"\x32\xD6")
io = KaitaiStream(BytesIO(self._raw_hp))
self.hp = Encrypted(u"xors2", io)
self._raw__raw_attack = self._io.read_bytes(2)
self._raw_attack = KaitaiStream.process_xor_many(self._raw__raw_attack, b"\xA0\x14")
io = KaitaiStream(BytesIO(self._raw_attack))
self.attack = Encrypted(u"xors2", io)
self._raw__raw_speed = self._io.read_bytes(2)
self._raw_speed = KaitaiStream.process_xor_many(self._raw__raw_speed, b"\x5E\xA5")
io = KaitaiStream(BytesIO(self._raw_speed))
self.speed = Encrypted(u"xors2", io)
self._raw__raw_defense = self._io.read_bytes(2)
self._raw_defense = KaitaiStream.process_xor_many(self._raw__raw_defense, b"\x66\x85")
io = KaitaiStream(BytesIO(self._raw_defense))
self.defense = Encrypted(u"xors2", io)
self._raw__raw_resistance = self._io.read_bytes(2)
self._raw_resistance = KaitaiStream.process_xor_many(self._raw__raw_resistance, b"\xE5\xAE")
io = KaitaiStream(BytesIO(self._raw_resistance))
self.resistance = Encrypted(u"xors2", io)
self.unknown1 = self._io.read_s2le()
self.unknown2 = self._io.read_s2le()
self.unknown3 = self._io.read_s2le()
def _read(self):
self.magic = self._io.ensure_fixed_contents(b"\x43\x50\x5A\x37")
self.archive_data_entry_count = self._io.read_u4le()
self.archive_data_size = self._io.read_u4le()
self.file_data_size = self._io.read_u4le()
self.raw_data_md5 = self._io.read_bytes(16)
self._raw_cpz7_md5 = self._io.read_bytes(16)
self.cpz7_md5 = KaitaiStream.process_xor_many(
self._raw_cpz7_md5,
b"\x1A\x7C\xDE\x43\x16\xF4\x65\xCC\x3D\xA9\x16\xD0\x9B\xBA\xA3\x97"
)
self.archive_data_key = self._io.read_u4le()
self.unknown_34 = self._io.read_u4le()
self.file_decrypt_key = self._io.read_u4le()
self.unknown15_3c = self._io.read_u4le()
self.encryption_data_size = self._io.read_u4le()
self.checksum = self._io.read_u4le()
def _read(self):
self.id_tag = CryptString(u"ID", self._io)
self.sprite_base = [None] * (2)
for i in range(2):
self.sprite_base[i] = CryptString(u"NONE", self._io)
self.base_weapon = CryptString(u"ID", self._io)
self._raw__raw_index = self._io.read_bytes(4)
self._raw_index = KaitaiStream.process_xor_many(self._raw__raw_index, b"\x0C\x41\xD3\x90")
io = KaitaiStream(BytesIO(self._raw_index))
self.index = WeaponIndex(io)
self.color = self._root.ColorEnum(self._io.read_u1())
self._raw__raw_range = self._io.read_bytes(1)
self._raw_range = KaitaiStream.process_xor_many(self._raw__raw_range, b"\x8B")
io = KaitaiStream(BytesIO(self._raw_range))
self.range = Encrypted(u"xoru1", io)
self._raw__raw_unknown1 = self._io.read_bytes(1)
self._raw_unknown1 = KaitaiStream.process_xor_many(self._raw__raw_unknown1, b"\xD0")
io = KaitaiStream(BytesIO(self._raw_unknown1))
self.unknown1 = Encrypted(u"xoru1", io)
self._raw__raw_equip_group = self._io.read_bytes(1)
self._raw_equip_group = KaitaiStream.process_xor_many(self._raw__raw_equip_group, b"\xB7")
io = KaitaiStream(BytesIO(self._raw_equip_group))
self.equip_group = Encrypted(u"xoru1", io)
self._raw__raw_res_damage = self._io.read_bytes(1)
self._raw_res_damage = KaitaiStream.process_xor_many(self._raw__raw_res_damage, b"\x07")
io = KaitaiStream(BytesIO(self._raw_res_damage))
self.res_damage = Xorb1(io)
self._raw__raw_is_staff = self._io.read_bytes(1)
self._raw_is_staff = KaitaiStream.process_xor_many(self._raw__raw_is_staff, b"\x78")
io = KaitaiStream(BytesIO(self._raw_is_staff))
self.is_staff = Xorb1(io)
self._raw__raw_is_dagger = self._io.read_bytes(1)
self._raw_is_dagger = KaitaiStream.process_xor_many(self._raw__raw_is_dagger, b"\xD7")
io = KaitaiStream(BytesIO(self._raw_is_dagger))
self.is_dagger = Xorb1(io)
self._raw__raw_is_breath = self._io.read_bytes(1)
self._raw_is_breath = KaitaiStream.process_xor_many(self._raw__raw_is_breath, b"\x11")
io = KaitaiStream(BytesIO(self._raw_is_breath))
self.is_breath = Xorb1(io)
self.padding = self._io.read_bytes(4)
def _read(self):
self.id_tag = CryptString(u"ID", self._io)
self.roman = CryptString(u"ID", self._io)
self.face_name = CryptString(u"ID", self._io)
self.face_name_2 = CryptString(u"ID", self._io)
self.top_weapon = CryptString(u"ID", self._io)
self._raw__raw_timestamp = self._io.read_bytes(8)
self._raw_timestamp = KaitaiStream.process_xor_many(
self._raw__raw_timestamp, b"\x9B\x48\xB6\xE9\x42\xE7\xC1\xBD")
io = KaitaiStream(BytesIO(self._raw_timestamp))
self.timestamp = Encrypted(u"xors8", io)
self._raw__raw_id_num = self._io.read_bytes(4)
self._raw_id_num = KaitaiStream.process_xor_many(
self._raw__raw_id_num, b"\xD4\x41\x2F\x42")
io = KaitaiStream(BytesIO(self._raw_id_num))
self.id_num = Encrypted(u"xoru4", io)
self._raw__raw_weapon_type = self._io.read_bytes(1)
self._raw_weapon_type = KaitaiStream.process_xor_many(
self._raw__raw_weapon_type, b"\xE4")
io = KaitaiStream(BytesIO(self._raw_weapon_type))
self.weapon_type = WeaponIndex(io)
self._raw__raw_tome_class = self._io.read_bytes(1)
self._raw_tome_class = KaitaiStream.process_xor_many(
self._raw__raw_tome_class, b"\x81")
io = KaitaiStream(BytesIO(self._raw_tome_class))
self.tome_class = MagicElement(io)
self._raw__raw_move_type = self._io.read_bytes(1)
self._raw_move_type = KaitaiStream.process_xor_many(
self._raw__raw_move_type, b"\x0D")
io = KaitaiStream(BytesIO(self._raw_move_type))
self.move_type = MoveIndex(io)
self._raw__raw_unknown1 = self._io.read_bytes(1)
self._raw_unknown1 = KaitaiStream.process_xor_many(
self._raw__raw_unknown1, b"\xC5")
io = KaitaiStream(BytesIO(self._raw_unknown1))
self.unknown1 = Xorb1(io)
self._raw__raw_is_boss = self._io.read_bytes(1)
self._raw_is_boss = KaitaiStream.process_xor_many(
self._raw__raw_is_boss, b"\x6A")
io = KaitaiStream(BytesIO(self._raw_is_boss))
self.is_boss = Xorb1(io)
self.padding = self._io.read_bytes(7)
self.base_stats = StatsTuple(self._io)
self.growth_rates = StatsTuple(self._io)
def _read(self):
self.id_tag = CryptString(u"ID", self._io)
self.skills = [None] * (7)
for i in range(7):
self.skills[i] = CryptString(u"ID", self._io)
self.accessory = CryptString(u"ID", self._io)
self.pos = MapPosition(self._io)
self._raw__raw_rarity = self._io.read_bytes(1)
self._raw_rarity = KaitaiStream.process_xor_many(
self._raw__raw_rarity, b"\x61")
io = KaitaiStream(BytesIO(self._raw_rarity))
self.rarity = Encrypted(u"xoru1", io)
self._raw__raw_lv = self._io.read_bytes(1)
self._raw_lv = KaitaiStream.process_xor_many(self._raw__raw_lv,
b"\x2A")
io = KaitaiStream(BytesIO(self._raw_lv))
self.lv = Encrypted(u"xoru1", io)
self._raw__raw_cooldown_count = self._io.read_bytes(1)
self._raw_cooldown_count = KaitaiStream.process_xor_many(
self._raw__raw_cooldown_count, b"\x1E")
io = KaitaiStream(BytesIO(self._raw_cooldown_count))
self.cooldown_count = Encrypted(u"xors1", io)
self.unknown1 = self._io.read_u1()
self.stats = StatsTuple(self._io)
self._raw__raw_start_turn = self._io.read_bytes(1)
self._raw_start_turn = KaitaiStream.process_xor_many(
self._raw__raw_start_turn, b"\xCF")
io = KaitaiStream(BytesIO(self._raw_start_turn))
self.start_turn = Encrypted(u"xors1", io)
self._raw__raw_movement_group = self._io.read_bytes(1)
self._raw_movement_group = KaitaiStream.process_xor_many(
self._raw__raw_movement_group, b"\xF4")
io = KaitaiStream(BytesIO(self._raw_movement_group))
self.movement_group = Encrypted(u"xors1", io)
self._raw__raw_movement_delay = self._io.read_bytes(1)
self._raw_movement_delay = KaitaiStream.process_xor_many(
self._raw__raw_movement_delay, b"\x95")
io = KaitaiStream(BytesIO(self._raw_movement_delay))
self.movement_delay = Encrypted(u"xors1", io)
self._raw__raw_break_terrain = self._io.read_bytes(1)
self._raw_break_terrain = KaitaiStream.process_xor_many(
self._raw__raw_break_terrain, b"\x71")
io = KaitaiStream(BytesIO(self._raw_break_terrain))
self.break_terrain = Xorb1(io)
self._raw__raw_tether = self._io.read_bytes(1)
self._raw_tether = KaitaiStream.process_xor_many(
self._raw__raw_tether, b"\xB8")
io = KaitaiStream(BytesIO(self._raw_tether))
self.tether = Xorb1(io)
self._raw__raw_true_lv = self._io.read_bytes(1)
self._raw_true_lv = KaitaiStream.process_xor_many(
self._raw__raw_true_lv, b"\x85")
io = KaitaiStream(BytesIO(self._raw_true_lv))
self.true_lv = Encrypted(u"xoru1", io)
self._raw__raw_is_enemy = self._io.read_bytes(1)
self._raw_is_enemy = KaitaiStream.process_xor_many(
self._raw__raw_is_enemy, b"\xD0")
io = KaitaiStream(BytesIO(self._raw_is_enemy))
self.is_enemy = Xorb1(io)
self.padding = self._io.read_bytes(1)
self.spawn_check = CryptString(u"ID", self._io)
self._raw__raw_spawn_count = self._io.read_bytes(1)
self._raw_spawn_count = KaitaiStream.process_xor_many(
self._raw__raw_spawn_count, b"\x0A")
io = KaitaiStream(BytesIO(self._raw_spawn_count))
self.spawn_count = Encrypted(u"xors1", io)
self._raw__raw_spawn_turns = self._io.read_bytes(1)
self._raw_spawn_turns = KaitaiStream.process_xor_many(
self._raw__raw_spawn_turns, b"\x0A")
io = KaitaiStream(BytesIO(self._raw_spawn_turns))
self.spawn_turns = Encrypted(u"xors1", io)
self._raw__raw_spawn_target_remain = self._io.read_bytes(1)
self._raw_spawn_target_remain = KaitaiStream.process_xor_many(
self._raw__raw_spawn_target_remain, b"\x2D")
io = KaitaiStream(BytesIO(self._raw_spawn_target_remain))
self.spawn_target_remain = Encrypted(u"xors1", io)
self._raw__raw_spawn_target_kills = self._io.read_bytes(1)
self._raw_spawn_target_kills = KaitaiStream.process_xor_many(
self._raw__raw_spawn_target_kills, b"\x5B")
io = KaitaiStream(BytesIO(self._raw_spawn_target_kills))
self.spawn_target_kills = Encrypted(u"xors1", io)
self.padding2 = self._io.read_bytes(4)
def _read(self):
self.id_tag = CryptString(u"ID", self._io)
self.refine_base = CryptString(u"ID", self._io)
self.name_id = CryptString(u"ID", self._io)
self.desc_id = CryptString(u"ID", self._io)
self.refine_id = CryptString(u"ID", self._io)
self.beast_effect_id = CryptString(u"ID", self._io)
self.prerequisites = [None] * (2)
for i in range(2):
self.prerequisites[i] = CryptString(u"ID", self._io)
self.next_skill = CryptString(u"ID", self._io)
self.sprites = [None] * (4)
for i in range(4):
self.sprites[i] = CryptString(u"NONE", self._io)
self.stats = StatsTuple(self._io)
self.class_params = StatsTuple(self._io)
self.skill_params = StatsTuple(self._io)
self.refine_stats = StatsTuple(self._io)
self._raw__raw_num_id = self._io.read_bytes(4)
self._raw_num_id = KaitaiStream.process_xor_many(
self._raw__raw_num_id, b"\x23\x3A\xA5\xC6")
io = KaitaiStream(BytesIO(self._raw_num_id))
self.num_id = Encrypted(u"xoru4", io)
self._raw__raw_sort_id = self._io.read_bytes(4)
self._raw_sort_id = KaitaiStream.process_xor_many(
self._raw__raw_sort_id, b"\xAC\xF8\xDB\x8D")
io = KaitaiStream(BytesIO(self._raw_sort_id))
self.sort_id = Encrypted(u"xoru4", io)
self._raw__raw_icon_id = self._io.read_bytes(4)
self._raw_icon_id = KaitaiStream.process_xor_many(
self._raw__raw_icon_id, b"\x73\x21\xDF\xC6")
io = KaitaiStream(BytesIO(self._raw_icon_id))
self.icon_id = Encrypted(u"xoru4", io)
self._raw__raw_wep_equip = self._io.read_bytes(4)
self._raw_wep_equip = KaitaiStream.process_xor_many(
self._raw__raw_wep_equip, b"\x28\x98\xB9\x35")
io = KaitaiStream(BytesIO(self._raw_wep_equip))
self.wep_equip = Encrypted(u"xoru4", io)
self._raw__raw_mov_equip = self._io.read_bytes(4)
self._raw_mov_equip = KaitaiStream.process_xor_many(
self._raw__raw_mov_equip, b"\xEB\x18\x28\xAB")
io = KaitaiStream(BytesIO(self._raw_mov_equip))
self.mov_equip = Encrypted(u"xoru4", io)
self._raw__raw_sp_cost = self._io.read_bytes(4)
self._raw_sp_cost = KaitaiStream.process_xor_many(
self._raw__raw_sp_cost, b"\x69\xF6\x31\xC0")
io = KaitaiStream(BytesIO(self._raw_sp_cost))
self.sp_cost = Encrypted(u"xoru4", io)
self._raw__raw_category = self._io.read_bytes(1)
self._raw_category = KaitaiStream.process_xor_many(
self._raw__raw_category, b"\xBC")
io = KaitaiStream(BytesIO(self._raw_category))
self.category = Encrypted(u"xoru1", io)
self._raw__raw_tome_class = self._io.read_bytes(1)
self._raw_tome_class = KaitaiStream.process_xor_many(
self._raw__raw_tome_class, b"\xF1")
io = KaitaiStream(BytesIO(self._raw_tome_class))
self.tome_class = MagicElement(io)
self._raw__raw_exclusive = self._io.read_bytes(1)
self._raw_exclusive = KaitaiStream.process_xor_many(
self._raw__raw_exclusive, b"\xCC")
io = KaitaiStream(BytesIO(self._raw_exclusive))
self.exclusive = Xorb1(io)
self._raw__raw_enemy_only = self._io.read_bytes(1)
self._raw_enemy_only = KaitaiStream.process_xor_many(
self._raw__raw_enemy_only, b"\x4F")
io = KaitaiStream(BytesIO(self._raw_enemy_only))
self.enemy_only = Xorb1(io)
self._raw__raw_range = self._io.read_bytes(1)
self._raw_range = KaitaiStream.process_xor_many(
self._raw__raw_range, b"\x56")
io = KaitaiStream(BytesIO(self._raw_range))
self.range = Encrypted(u"xoru1", io)
self._raw__raw_might = self._io.read_bytes(1)
self._raw_might = KaitaiStream.process_xor_many(
self._raw__raw_might, b"\xD2")
io = KaitaiStream(BytesIO(self._raw_might))
self.might = Encrypted(u"xoru1", io)
self._raw__raw_cooldown_count = self._io.read_bytes(1)
self._raw_cooldown_count = KaitaiStream.process_xor_many(
self._raw__raw_cooldown_count, b"\x56")
io = KaitaiStream(BytesIO(self._raw_cooldown_count))
self.cooldown_count = Encrypted(u"xors1", io)
self._raw__raw_assist_cd = self._io.read_bytes(1)
self._raw_assist_cd = KaitaiStream.process_xor_many(
self._raw__raw_assist_cd, b"\xF2")
io = KaitaiStream(BytesIO(self._raw_assist_cd))
self.assist_cd = Xorb1(io)
self._raw__raw_healing = self._io.read_bytes(1)
self._raw_healing = KaitaiStream.process_xor_many(
self._raw__raw_healing, b"\x95")
io = KaitaiStream(BytesIO(self._raw_healing))
self.healing = Xorb1(io)
self._raw__raw_skill_range = self._io.read_bytes(1)
self._raw_skill_range = KaitaiStream.process_xor_many(
self._raw__raw_skill_range, b"\x09")
io = KaitaiStream(BytesIO(self._raw_skill_range))
self.skill_range = Encrypted(u"xoru1", io)
self._raw__raw_score = self._io.read_bytes(2)
self._raw_score = KaitaiStream.process_xor_many(
self._raw__raw_score, b"\x32\xA2")
io = KaitaiStream(BytesIO(self._raw_score))
self.score = Encrypted(u"xoru2", io)
self._raw__raw_promotion_tier = self._io.read_bytes(1)
self._raw_promotion_tier = KaitaiStream.process_xor_many(
self._raw__raw_promotion_tier, b"\xE0")
io = KaitaiStream(BytesIO(self._raw_promotion_tier))
self.promotion_tier = Encrypted(u"xoru1", io)
self._raw__raw_promotion_rarity = self._io.read_bytes(1)
self._raw_promotion_rarity = KaitaiStream.process_xor_many(
self._raw__raw_promotion_rarity, b"\x75")
io = KaitaiStream(BytesIO(self._raw_promotion_rarity))
self.promotion_rarity = Encrypted(u"xoru1", io)
self._raw__raw_refined = self._io.read_bytes(1)
self._raw_refined = KaitaiStream.process_xor_many(
self._raw__raw_refined, b"\x02")
io = KaitaiStream(BytesIO(self._raw_refined))
self.refined = Xorb1(io)
self._raw__raw_refine_sort_id = self._io.read_bytes(1)
self._raw_refine_sort_id = KaitaiStream.process_xor_many(
self._raw__raw_refine_sort_id, b"\xFC")
io = KaitaiStream(BytesIO(self._raw_refine_sort_id))
self.refine_sort_id = Encrypted(u"xoru1", io)
self._raw__raw_wep_effective = self._io.read_bytes(4)
self._raw_wep_effective = KaitaiStream.process_xor_many(
self._raw__raw_wep_effective, b"\x43\x3D\xBE\x23")
io = KaitaiStream(BytesIO(self._raw_wep_effective))
self.wep_effective = Encrypted(u"xoru4", io)
self._raw__raw_mov_effective = self._io.read_bytes(4)
self._raw_mov_effective = KaitaiStream.process_xor_many(
self._raw__raw_mov_effective, b"\xEB\xDA\x3F\x82")
io = KaitaiStream(BytesIO(self._raw_mov_effective))
self.mov_effective = Encrypted(u"xoru4", io)
self._raw__raw_wep_shield = self._io.read_bytes(4)
self._raw_wep_shield = KaitaiStream.process_xor_many(
self._raw__raw_wep_shield, b"\x43\xB7\xBA\xAA")
io = KaitaiStream(BytesIO(self._raw_wep_shield))
self.wep_shield = Encrypted(u"xoru4", io)
self._raw__raw_mov_shield = self._io.read_bytes(4)
self._raw_mov_shield = KaitaiStream.process_xor_many(
self._raw__raw_mov_shield, b"\x5B\xF2\xBE\x0E")
io = KaitaiStream(BytesIO(self._raw_mov_shield))
self.mov_shield = Encrypted(u"xoru4", io)
self._raw__raw_wep_weakness = self._io.read_bytes(4)
self._raw_wep_weakness = KaitaiStream.process_xor_many(
self._raw__raw_wep_weakness, b"\xAF\x02\x5A\x00")
io = KaitaiStream(BytesIO(self._raw_wep_weakness))
self.wep_weakness = Encrypted(u"xoru4", io)
self._raw__raw_mov_weakness = self._io.read_bytes(4)
self._raw_mov_weakness = KaitaiStream.process_xor_many(
self._raw__raw_mov_weakness, b"\x19\xB8\x69\xB2")
io = KaitaiStream(BytesIO(self._raw_mov_weakness))
self.mov_weakness = Encrypted(u"xoru4", io)
self._raw__raw_wep_adaptive = self._io.read_bytes(4)
self._raw_wep_adaptive = KaitaiStream.process_xor_many(
self._raw__raw_wep_adaptive, b"\x29\x26\x4E\x49")
io = KaitaiStream(BytesIO(self._raw_wep_adaptive))
self.wep_adaptive = Encrypted(u"xoru4", io)
self._raw__raw_mov_adaptive = self._io.read_bytes(4)
self._raw_mov_adaptive = KaitaiStream.process_xor_many(
self._raw__raw_mov_adaptive, b"\x2E\xEF\x6C\xEE")
io = KaitaiStream(BytesIO(self._raw_mov_adaptive))
self.mov_adaptive = Encrypted(u"xoru4", io)
self._raw__raw_timing_id = self._io.read_bytes(4)
self._raw_timing_id = KaitaiStream.process_xor_many(
self._raw__raw_timing_id, b"\x48\x66\x77\x9C")
io = KaitaiStream(BytesIO(self._raw_timing_id))
self.timing_id = Encrypted(u"xoru4", io)
self._raw__raw_ability_id = self._io.read_bytes(4)
self._raw_ability_id = KaitaiStream.process_xor_many(
self._raw__raw_ability_id, b"\x25\x73\xB0\x72")
io = KaitaiStream(BytesIO(self._raw_ability_id))
self.ability_id = Encrypted(u"xoru4", io)
self._raw__raw_limit1_id = self._io.read_bytes(4)
self._raw_limit1_id = KaitaiStream.process_xor_many(
self._raw__raw_limit1_id, b"\x32\xB8\xBD\x0E")
io = KaitaiStream(BytesIO(self._raw_limit1_id))
self.limit1_id = Encrypted(u"xoru4", io)
self._raw_limit1_params = [None] * (2)
self.limit1_params = [None] * (2)
for i in range(2):
self._raw__raw_limit1_params[i] = self._io.read_bytes(2)
self._raw_limit1_params = KaitaiStream.process_xor_many(
self._raw__raw_limit1_params, b"\x90\xA5")
io = KaitaiStream(BytesIO(self._raw_limit1_params[i]))
self.limit1_params[i] = Encrypted(u"xors2", io)
self._raw__raw_limit2_id = self._io.read_bytes(4)
self._raw_limit2_id = KaitaiStream.process_xor_many(
self._raw__raw_limit2_id, b"\x32\xB8\xBD\x0E")
io = KaitaiStream(BytesIO(self._raw_limit2_id))
self.limit2_id = Encrypted(u"xoru4", io)
self._raw_limit2_params = [None] * (2)
self.limit2_params = [None] * (2)
for i in range(2):
self._raw__raw_limit2_params[i] = self._io.read_bytes(2)
self._raw_limit2_params = KaitaiStream.process_xor_many(
self._raw__raw_limit2_params, b"\x90\xA5")
io = KaitaiStream(BytesIO(self._raw_limit2_params[i]))
self.limit2_params[i] = Encrypted(u"xors2", io)
self._raw__raw_target_wep = self._io.read_bytes(4)
self._raw_target_wep = KaitaiStream.process_xor_many(
self._raw__raw_target_wep, b"\xD7\xC9\x9F\x40")
io = KaitaiStream(BytesIO(self._raw_target_wep))
self.target_wep = Encrypted(u"xoru4", io)
self._raw__raw_target_mov = self._io.read_bytes(4)
self._raw_target_mov = KaitaiStream.process_xor_many(
self._raw__raw_target_mov, b"\x22\xD1\x64\x6C")
io = KaitaiStream(BytesIO(self._raw_target_mov))
self.target_mov = Encrypted(u"xoru4", io)
self.passive_next = CryptString(u"ID", self._io)
self._raw__raw_timestamp = self._io.read_bytes(8)
self._raw_timestamp = KaitaiStream.process_xor_many(
self._raw__raw_timestamp, b"\x51\x9F\xFE\x3B\xF9\x39\x3F\xED")
io = KaitaiStream(BytesIO(self._raw_timestamp))
self.timestamp = Encrypted(u"xors8", io)
self._raw__raw_unknown1 = self._io.read_bytes(1)
self._raw_unknown1 = KaitaiStream.process_xor_many(
self._raw__raw_unknown1, b"\x10")
io = KaitaiStream(BytesIO(self._raw_unknown1))
self.unknown1 = Encrypted(u"xoru1", io)
self._raw__raw_min_lv = self._io.read_bytes(1)
self._raw_min_lv = KaitaiStream.process_xor_many(
self._raw__raw_min_lv, b"\x90")
io = KaitaiStream(BytesIO(self._raw_min_lv))
self.min_lv = Encrypted(u"xoru1", io)
self._raw__raw_max_lv = self._io.read_bytes(1)
self._raw_max_lv = KaitaiStream.process_xor_many(
self._raw__raw_max_lv, b"\x24")
io = KaitaiStream(BytesIO(self._raw_max_lv))
self.max_lv = Encrypted(u"xoru1", io)
self._raw__raw_unknown2 = self._io.read_bytes(1)
self._raw_unknown2 = KaitaiStream.process_xor_many(
self._raw__raw_unknown2, b"\x19")
io = KaitaiStream(BytesIO(self._raw_unknown2))
self.unknown2 = Encrypted(u"xoru1", io)
self._raw__raw_unknown3 = self._io.read_bytes(1)
self._raw_unknown3 = KaitaiStream.process_xor_many(
self._raw__raw_unknown3, b"\xBD")
io = KaitaiStream(BytesIO(self._raw_unknown3))
self.unknown3 = Encrypted(u"xoru1", io)
self.padding = self._io.read_bytes(3)
self.id_tag2 = CryptString(u"ID", self._io)
self.next_seal = CryptString(u"ID", self._io)
self.prev_seal = CryptString(u"ID", self._io)
self._raw__raw_ss_coin = self._io.read_bytes(2)
self._raw_ss_coin = KaitaiStream.process_xor_many(
self._raw__raw_ss_coin, b"\x40\xC5")
io = KaitaiStream(BytesIO(self._raw_ss_coin))
self.ss_coin = Encrypted(u"xoru2", io)
self._raw__raw_ss_badge_type = self._io.read_bytes(2)
self._raw_ss_badge_type = KaitaiStream.process_xor_many(
self._raw__raw_ss_badge_type, b"\x0F\xD5")
io = KaitaiStream(BytesIO(self._raw_ss_badge_type))
self.ss_badge_type = BadgeColor(io)
self._raw__raw_ss_badge = self._io.read_bytes(2)
self._raw_ss_badge = KaitaiStream.process_xor_many(
self._raw__raw_ss_badge, b"\xEC\x8C")
io = KaitaiStream(BytesIO(self._raw_ss_badge))
self.ss_badge = Encrypted(u"xoru2", io)
self._raw__raw_ss_great_badge = self._io.read_bytes(2)
self._raw_ss_great_badge = KaitaiStream.process_xor_many(
self._raw__raw_ss_great_badge, b"\xFF\xCC")
io = KaitaiStream(BytesIO(self._raw_ss_great_badge))
self.ss_great_badge = Encrypted(u"xoru2", io)
def _read(self):
self.key = self._io.read_bytes(4)
self._raw_buf = self._io.read_bytes_full()
self.buf = KaitaiStream.process_xor_many(self._raw_buf, self.key)
def _read(self):
self._raw__raw_index = self._io.read_bytes(4)
self._raw_index = KaitaiStream.process_xor_many(
self._raw__raw_index, b"\xAB\xA1\xE0\xDA")
io = KaitaiStream(BytesIO(self._raw_index))
self.index = Encrypted(u"xoru4", io)
self._raw__raw_base_terrain = self._io.read_bytes(4)
self._raw_base_terrain = KaitaiStream.process_xor_many(
self._raw__raw_base_terrain, b"\xD2\x7D\xD0\x6F")
io = KaitaiStream(BytesIO(self._raw_base_terrain))
self.base_terrain = Encrypted(u"xors4", io)
self._raw__raw_foe_base_terrain = self._io.read_bytes(4)
self._raw_foe_base_terrain = KaitaiStream.process_xor_many(
self._raw__raw_foe_base_terrain, b"\xD2\x7D\xD0\x6F")
io = KaitaiStream(BytesIO(self._raw_foe_base_terrain))
self.foe_base_terrain = Encrypted(u"xors4", io)
self._raw__raw_side = self._io.read_bytes(1)
self._raw_side = KaitaiStream.process_xor_many(self._raw__raw_side,
b"\x21")
io = KaitaiStream(BytesIO(self._raw_side))
self.side = Encrypted(u"xors1", io)
self._raw__raw_terrain_group = self._io.read_bytes(1)
self._raw_terrain_group = KaitaiStream.process_xor_many(
self._raw__raw_terrain_group, b"\xCB")
io = KaitaiStream(BytesIO(self._raw_terrain_group))
self.terrain_group = Encrypted(u"xoru1", io)
self._raw__raw_inaccessible = self._io.read_bytes(1)
self._raw_inaccessible = KaitaiStream.process_xor_many(
self._raw__raw_inaccessible, b"\x16")
io = KaitaiStream(BytesIO(self._raw_inaccessible))
self.inaccessible = Xorb1(io)
self._raw__raw_hp = self._io.read_bytes(1)
self._raw_hp = KaitaiStream.process_xor_many(self._raw__raw_hp,
b"\xBA")
io = KaitaiStream(BytesIO(self._raw_hp))
self.hp = Encrypted(u"xoru1", io)
self._raw__raw_is_wall = self._io.read_bytes(1)
self._raw_is_wall = KaitaiStream.process_xor_many(
self._raw__raw_is_wall, b"\xA8")
io = KaitaiStream(BytesIO(self._raw_is_wall))
self.is_wall = Xorb1(io)
self._raw__raw_is_liquid = self._io.read_bytes(1)
self._raw_is_liquid = KaitaiStream.process_xor_many(
self._raw__raw_is_liquid, b"\x7C")
io = KaitaiStream(BytesIO(self._raw_is_liquid))
self.is_liquid = Xorb1(io)
self._raw__raw_is_bridge = self._io.read_bytes(1)
self._raw_is_bridge = KaitaiStream.process_xor_many(
self._raw__raw_is_bridge, b"\x08")
io = KaitaiStream(BytesIO(self._raw_is_bridge))
self.is_bridge = Xorb1(io)
self._raw__raw_is_trench = self._io.read_bytes(1)
self._raw_is_trench = KaitaiStream.process_xor_many(
self._raw__raw_is_trench, b"\x30")
io = KaitaiStream(BytesIO(self._raw_is_trench))
self.is_trench = Xorb1(io)
self._raw__raw_is_fortress = self._io.read_bytes(1)
self._raw_is_fortress = KaitaiStream.process_xor_many(
self._raw__raw_is_fortress, b"\xDA")
io = KaitaiStream(BytesIO(self._raw_is_fortress))
self.is_fortress = Xorb1(io)
self._raw__raw_is_rd_terrain = self._io.read_bytes(1)
self._raw_is_rd_terrain = KaitaiStream.process_xor_many(
self._raw__raw_is_rd_terrain, b"\xCD")
io = KaitaiStream(BytesIO(self._raw_is_rd_terrain))
self.is_rd_terrain = Xorb1(io)
self._raw__raw_mit_mod = self._io.read_bytes(1)
self._raw_mit_mod = KaitaiStream.process_xor_many(
self._raw__raw_mit_mod, b"\xAA")
io = KaitaiStream(BytesIO(self._raw_mit_mod))
self.mit_mod = Encrypted(u"xoru1", io)
self._raw__raw_regen_hp = self._io.read_bytes(1)
self._raw_regen_hp = KaitaiStream.process_xor_many(
self._raw__raw_regen_hp, b"\x7D")
io = KaitaiStream(BytesIO(self._raw_regen_hp))
self.regen_hp = Encrypted(u"xoru1", io)
def _read(self):
self.key = self._io.read_bytes(4)
self._raw_buf = self._io.read_bytes_full()
self.buf = KaitaiStream.process_xor_many(self._raw_buf,
b"\xEC\xBB\xA3\x14")
def _read(self):
self.id_tag = CryptString(u"ID", self._io)
self.roman = CryptString(u"ID", self._io)
self.face_name = CryptString(u"ID", self._io)
self.face_name_2 = CryptString(u"ID", self._io)
self.legendary_ptr = FilePtr(self._io)
self._raw__raw_timestamp = self._io.read_bytes(8)
self._raw_timestamp = KaitaiStream.process_xor_many(self._raw__raw_timestamp, b"\x9B\x48\xB6\xE9\x42\xE7\xC1\xBD")
io = KaitaiStream(BytesIO(self._raw_timestamp))
self.timestamp = Encrypted(u"xors8", io)
self._raw__raw_id_num = self._io.read_bytes(4)
self._raw_id_num = KaitaiStream.process_xor_many(self._raw__raw_id_num, b"\x18\x4E\x6E\x5F")
io = KaitaiStream(BytesIO(self._raw_id_num))
self.id_num = Encrypted(u"xoru4", io)
self._raw__raw_sort_value = self._io.read_bytes(4)
self._raw_sort_value = KaitaiStream.process_xor_many(self._raw__raw_sort_value, b"\x9B\x34\x80\x2A")
io = KaitaiStream(BytesIO(self._raw_sort_value))
self.sort_value = Encrypted(u"xoru4", io)
self._raw__raw_weapon_type = self._io.read_bytes(1)
self._raw_weapon_type = KaitaiStream.process_xor_many(self._raw__raw_weapon_type, b"\x06")
io = KaitaiStream(BytesIO(self._raw_weapon_type))
self.weapon_type = WeaponIndex(io)
self._raw__raw_tome_class = self._io.read_bytes(1)
self._raw_tome_class = KaitaiStream.process_xor_many(self._raw__raw_tome_class, b"\x35")
io = KaitaiStream(BytesIO(self._raw_tome_class))
self.tome_class = MagicElement(io)
self._raw__raw_move_type = self._io.read_bytes(1)
self._raw_move_type = KaitaiStream.process_xor_many(self._raw__raw_move_type, b"\x2A")
io = KaitaiStream(BytesIO(self._raw_move_type))
self.move_type = MoveIndex(io)
self._raw__raw_series = self._io.read_bytes(1)
self._raw_series = KaitaiStream.process_xor_many(self._raw__raw_series, b"\x43")
io = KaitaiStream(BytesIO(self._raw_series))
self.series = Encrypted(u"xoru1", io)
self._raw__raw_regular_hero = self._io.read_bytes(1)
self._raw_regular_hero = KaitaiStream.process_xor_many(self._raw__raw_regular_hero, b"\xA1")
io = KaitaiStream(BytesIO(self._raw_regular_hero))
self.regular_hero = Xorb1(io)
self._raw__raw_permanent_hero = self._io.read_bytes(1)
self._raw_permanent_hero = KaitaiStream.process_xor_many(self._raw__raw_permanent_hero, b"\xC7")
io = KaitaiStream(BytesIO(self._raw_permanent_hero))
self.permanent_hero = Xorb1(io)
self._raw__raw_base_vector_id = self._io.read_bytes(1)
self._raw_base_vector_id = KaitaiStream.process_xor_many(self._raw__raw_base_vector_id, b"\x3D")
io = KaitaiStream(BytesIO(self._raw_base_vector_id))
self.base_vector_id = Encrypted(u"xoru1", io)
self._raw__raw_refresher = self._io.read_bytes(1)
self._raw_refresher = KaitaiStream.process_xor_many(self._raw__raw_refresher, b"\xFF")
io = KaitaiStream(BytesIO(self._raw_refresher))
self.refresher = Xorb1(io)
self.unknown2 = self._io.read_u1()
self.padding = self._io.read_bytes(7)
self.base_stats = StatsTuple(self._io)
self.growth_rates = StatsTuple(self._io)
self.max_stats = StatsTuple(self._io)
self.skills = [None] * ((5 * 14))
for i in range((5 * 14)):
self.skills[i] = CryptString(u"ID", self._io)
