def add_wan(self, obj_name):
self._tree_level_iter[obj_name] = self._tree_model.append(
self._root, [
'skytemple-e-object-symbolic', obj_name, self,
ObjectController, obj_name, False, '', True
])
recursive_generate_item_store_row_label(self._tree_model[self._root])
def load_tree_items(self, item_store: TreeStore, root_node):
self._validator = DungeonValidator(self.get_mappa().floor_lists)
root = item_store.append(root_node, [
ICON_ROOT, DUNGEONS_NAME, self, MainController, 0, False, '', True
])
self._tree_model = item_store
self._root_iter = root
static_data = self.project.get_rom_module().get_static_data()
self._fixed_floor_data = self.project.open_file_in_rom(
FIXED_PATH, FileType.FIXED_BIN, static_data=static_data)
self._dungeon_bin: DungeonBinPack = self.project.open_file_in_rom(
DUNGEON_BIN, FileType.DUNGEON_BIN, static_data=static_data)
self._validator.validate(self.get_dungeon_list())
self._fill_dungeon_tree()
# Fixed rooms
self._fixed_floor_root_iter = item_store.append(
root_node, [
ICON_FIXED_ROOMS, FIXED_ROOMS_NAME, self, FixedRoomsController,
0, False, '', True
])
for i in range(0, len(self._fixed_floor_data.fixed_floors)):
self._fixed_floor_iters.append(
item_store.append(self._fixed_floor_root_iter, [
ICON_FIXED_ROOMS,
f(_('Fixed Room {i}')), self, FixedController, i, False,
'', True
]))
recursive_generate_item_store_row_label(self._tree_model[root])
recursive_generate_item_store_row_label(
self._tree_model[self._fixed_floor_root_iter])
def load_tree_items(self, item_store: TreeStore, root_node):
root_items = item_store.append(root_node, [
'skytemple-e-item-symbolic', ITEMS, self, MainItemsController, 0, False, '', True
])
root_moves = item_store.append(root_node, [
'skytemple-e-move-symbolic', MOVES, self, MainMovesController, 0, False, '', True
])
self._item_lists_tree_iter = item_store.append(root_items, [
'skytemple-view-list-symbolic', _('Item Lists'), self, ItemListsController, 0, False, '', True
])
self._item_effects_tree_iter = item_store.append(root_items, [
'skytemple-view-list-symbolic', _('Item Effects'), self, ItemEffectsController, 0, False, '', True
])
self._move_effects_tree_iter = item_store.append(root_moves, [
'skytemple-view-list-symbolic', _('Move Effects'), self, MoveEffectsController, 0, False, '', True
])
for i, item in enumerate(self.get_item_p().item_list):
name = self.project.get_string_provider().get_value(StringType.ITEM_NAMES, i)
self.item_iters[i] = (item_store.append(root_items, [
'skytemple-e-item-symbolic', f'#{i:04}: {name}', self, ItemController, i, False, '', True
]))
for i, item in enumerate(self.get_waza_p().moves):
name = self.project.get_string_provider().get_value(StringType.MOVE_NAMES, i)
self.move_iters[i] = (item_store.append(root_moves, [
'skytemple-e-move-symbolic', f'#{i:04}: {name}', self, MoveController, i, False, '', True
]))
recursive_generate_item_store_row_label(item_store[root_items])
recursive_generate_item_store_row_label(item_store[root_moves])
self._tree_model = item_store
def load_tree_items(self, item_store: TreeStore, root_node):
root = item_store.append(root_node, [
'skytemple-e-monster-symbolic', MONSTER_NAME, self, MainController,
0, False, '', True
])
self._tree_model = item_store
self._tree_iter__entity_roots = {}
self._tree_iter__entries = {}
monster_entries_by_base_id: Dict[int, List[MdEntry]] = {}
for entry in self.monster_md.entries:
if entry.md_index_base not in monster_entries_by_base_id:
monster_entries_by_base_id[entry.md_index_base] = []
monster_entries_by_base_id[entry.md_index_base].append(entry)
for baseid, entry_list in monster_entries_by_base_id.items():
name = self.project.get_string_provider().get_value(
StringType.POKEMON_NAMES, baseid)
ent_root = item_store.append(
root, self.generate_entry__entity_root(baseid, name))
self._tree_iter__entity_roots[baseid] = ent_root
for entry in entry_list:
self._tree_iter__entries[entry.md_index] = item_store.append(
ent_root,
self.generate_entry__entry(entry.md_index, entry.gender))
recursive_generate_item_store_row_label(self._tree_model[root])
def load_tree_items(self, item_store: TreeStore, root_node):
self.dungeon_bin: DungeonBinPack = self.project.open_file_in_rom(
DUNGEON_BIN,
FileType.DUNGEON_BIN,
static_data=self.project.get_rom_module().get_static_data())
root = item_store.append(root_node, [
'skytemple-e-dungeon-tileset-symbolic', DUNGEON_GRAPHICS_NAME,
self, MainController, 0, False, '', True
])
self._tree_model = item_store
self._tree_level_iter = []
for i in range(0, NUMBER_OF_TILESETS):
self._tree_level_iter.append(
item_store.append(root, [
'skytemple-e-dungeon-tileset-symbolic',
f"{_('Tileset')} {i}", self, TilesetController, i, False,
'', True
]))
for i in range(0, NUMBER_OF_BACKGROUNDS):
self._tree_level_iter.append(
item_store.append(root, [
'skytemple-e-mapbg-symbolic',
f"{_('Background')} {i + NUMBER_OF_TILESETS}", self,
DungeonBgController, i, False, '', True
]))
self._tree_level_iter.append(
item_store.append(root, [
'skytemple-e-dungeon-tileset-symbolic',
_("Color Map"), self, ColvecController, i, False, '', True
]))
self._colvec_pos = len(self._tree_level_iter) - 1
recursive_generate_item_store_row_label(self._tree_model[root])
def rebuild_dungeon_tree(self):
# Collect modified of _dungeon_iters and _dungeon_floor_iters
modified_dungeons = {
x: self._tree_model[y][5]
for x, y in self._dungeon_iters.items()
}
modified_floors = {}
for dungeon, floors in self._dungeon_floor_iters.items():
modified_floors[dungeon] = {
x: self._tree_model[y][5]
for x, y in floors.items()
}
# Delete everything under _root_iter
child = self._tree_model.iter_children(self._root_iter)
while child is not None:
nxt = self._tree_model.iter_next(child)
self._tree_model.remove(child)
child = nxt
self._dungeon_iters = {}
self._dungeon_floor_iters = {}
# _fill_dungeon_tree
self._fill_dungeon_tree()
# Apply modified of _dungeon_iters and _dungeon_floor_iters
for dungeon, modified in modified_dungeons.items():
if dungeon in self._dungeon_iters:
self._tree_model[self._dungeon_iters[dungeon]][5] = modified
for dungeon, floors in modified_floors.items():
if dungeon in self._dungeon_floor_iters:
for floor, modified in floors.items():
if floor in self._dungeon_floor_iters[dungeon]:
self._tree_model[self._dungeon_floor_iters[dungeon]
[floor]][5] = modified
# Re-generate label
recursive_generate_item_store_row_label(
self._tree_model[self._root_iter])
def load_tree_items(self, item_store: TreeStore, root_node):
self.dungeon_bin_context: ModelContext[
DungeonBinPack] = self.project.open_file_in_rom(
DUNGEON_BIN,
FileType.DUNGEON_BIN,
static_data=self.project.get_rom_module().get_static_data(),
threadsafe=True)
root = self._root_node = item_store.append(root_node, [
'skytemple-e-dungeon-tileset-symbolic', DUNGEON_GRAPHICS_NAME,
self, MainController, 0, False, '', True
])
tileset_root = item_store.append(root, [
'skytemple-e-dungeon-tileset-symbolic', TILESETS_NAME, self,
TilesetMainController, 0, False, '', True
])
bg_root = item_store.append(root, [
'skytemple-e-mapbg-symbolic', BACKGROUNDS_NAMES, self,
DungeonBgMainController, 0, False, '', True
])
self._tree_model = item_store
self._tree_level_iter = []
for i in range(0, NUMBER_OF_TILESETS):
self._tree_level_iter.append(
item_store.append(tileset_root, [
'skytemple-e-dungeon-tileset-symbolic',
f"{_('Tileset')} {i}", self, TilesetController, i, False,
'', True
]))
for i in range(0, NUMBER_OF_BACKGROUNDS):
self._tree_level_iter.append(
item_store.append(bg_root, [
'skytemple-e-mapbg-symbolic',
f"{_('Background')} {i + NUMBER_OF_TILESETS}", self,
DungeonBgController, i, False, '', True
]))
self._tree_level_iter.append(
item_store.append(root, [
'skytemple-e-graphics-symbolic', f"Traps", self,
TrpItmImgController, ImgType.TRP, False, '', True
]))
self._traps_pos = len(self._tree_level_iter) - 1
self._tree_level_iter.append(
item_store.append(root, [
'skytemple-e-graphics-symbolic', f"Items", self,
TrpItmImgController, ImgType.ITM, False, '', True
]))
self._items_pos = len(self._tree_level_iter) - 1
self._tree_level_iter.append(
item_store.append(root, [
'skytemple-e-dungeon-tileset-symbolic',
_("Color Map"), self, ColvecController, i, False, '', True
]))
self._colvec_pos = len(self._tree_level_iter) - 1
recursive_generate_item_store_row_label(self._tree_model[root])
def load_tree_items(self, item_store: TreeStore, root_node):
root = item_store.append(root_node, [
'skytemple-e-string-symbolic', TEXT_STRINGS, self, MainController, 0, False, '', True
])
config = self.project.get_rom_module().get_static_data()
for language in config.string_index_data.languages:
self._tree_iters[language.filename] = item_store.append(root, [
'skytemple-e-string-symbolic', language.name_localized, self, StringsController, language, False, '', True
])
self._tree_model = item_store
recursive_generate_item_store_row_label(self._tree_model[root])
def load_tree_items(self, item_store: TreeStore, root_node):
root = item_store.append(root_node, [
'skytemple-e-object-symbolic', OBJECT_SPRTIES, self, ObjectMainController, 0, False, '', True
])
self._tree_model = item_store
self._tree_level_iter = {}
for name in self.list_of_obj_sprites:
self._tree_level_iter[name] = item_store.append(root, [
'skytemple-e-object-symbolic', name, self, ObjectController, name, False, '', True
])
recursive_generate_item_store_row_label(self._tree_model[root])
def load_tree_items(self, item_store: TreeStore, root_node):
root = item_store.append(root_node, [
'skytemple-e-bgp-symbolic', BACKGROUNDS_NAME, self, MainController, 0, False, '', True
])
self._tree_model = item_store
self._tree_level_iter = []
for i, bgp_name in enumerate(self.list_of_bgps):
self._tree_level_iter.append(
item_store.append(root, [
'skytemple-e-bgp-symbolic', bgp_name, self, BgpController, i, False, '', True
])
)
recursive_generate_item_store_row_label(self._tree_model[root])
def add_map(self, map_name):
item_id = len(self.bgs.level)
self.bgs.level.append(
BgListEntry(map_name, map_name, map_name, [None] * 8)
)
parent = self._other_node
if map_name[0] in self._sub_nodes.keys():
parent = self._sub_nodes[map_name[0]]
self._tree_level_iter.append(
self._tree_model.append(parent, [
'skytemple-e-mapbg-symbolic', map_name, self, BgController, item_id, False, '', True
])
)
recursive_generate_item_store_row_label(self._tree_model[parent])
self.mark_as_modified(item_id)
self.mark_level_list_as_modified()
def load_tree_items(self, item_store: TreeStore, root_node):
root = item_store.append(root_node, [
'skytemple-e-mapbg-symbolic', MAPBG_NAME, self, MainController, 0, False, '', True
])
self._sub_nodes = {
'S': item_store.append(root, [
'skytemple-folder-symbolic', _('S - System'), self, FolderController, 'S - System', False, '', True
]),
'T': item_store.append(root, [
'skytemple-folder-symbolic', _('T - Town'), self, FolderController, 'T - Town', False, '', True
]),
'D': item_store.append(root, [
'skytemple-folder-symbolic', _('D - Dungeon'), self, FolderController, 'D - Dungeon', False, '', True
]),
'G': item_store.append(root, [
'skytemple-folder-symbolic', _('G - Guild'), self, FolderController, 'G - Guild', False, '', True
]),
'H': item_store.append(root, [
'skytemple-folder-symbolic', _('H - Habitat'), self, FolderController, 'H - Habitat', False, '', True
]),
'P': item_store.append(root, [
'skytemple-folder-symbolic', _('P - Places'), self, FolderController, 'P - Places', False, '', True
]),
'V': item_store.append(root, [
'skytemple-folder-symbolic', _('V - Visual'), self, FolderController, 'V - Visual', False, '', True
]),
'W': item_store.append(root, [
'skytemple-folder-symbolic', _('W - Weather'), self, FolderController, 'W - Weather', False, '', True
])
}
# Other
self._other_node = item_store.append(root, [
'skytemple-folder-symbolic', _('Others'), self, FolderController, None, False, '', True
])
self._tree_model = item_store
self._tree_level_iter = []
for i, level in enumerate(self.bgs.level):
parent = self._other_node
if level.bma_name[0] in self._sub_nodes.keys():
parent = self._sub_nodes[level.bma_name[0]]
self._tree_level_iter.append(
item_store.append(parent, [
'skytemple-e-mapbg-symbolic', level.bma_name, self, BgController, i, False, '', True
])
)
recursive_generate_item_store_row_label(self._tree_model[root])
def load_tree_items(self, item_store: TreeStore, root_node):
if self._errored:
display_error(
self._errored,
_("The dungeon floor data of this ROM is corrupt. SkyTemple will still try to open it, "
"but dungeon editing will not be available. Expect other bugs. Please fix your ROM."
), _("SkyTemple"))
return
self._validator = DungeonValidator(self.get_mappa().floor_lists)
root = item_store.append(root_node, [
ICON_ROOT, DUNGEONS_NAME, self, MainController, 0, False, '', True
])
self._tree_model = item_store
self._root_iter = root
static_data = self.project.get_rom_module().get_static_data()
self._fixed_floor_data = self.project.open_file_in_rom(
FIXED_PATH, FileType.FIXED_BIN, static_data=static_data)
self._dungeon_bin_context: ModelContext[
DungeonBinPack] = self.project.open_file_in_rom(
DUNGEON_BIN,
FileType.DUNGEON_BIN,
static_data=static_data,
threadsafe=True)
self._validator.validate(self.get_dungeon_list())
self._fill_dungeon_tree()
# Fixed rooms
self._fixed_floor_root_iter = item_store.append(
root_node, [
ICON_FIXED_ROOMS, FIXED_ROOMS_NAME, self, FixedRoomsController,
0, False, '', True
])
for i in range(0, len(self._fixed_floor_data.fixed_floors)):
self._fixed_floor_iters.append(
item_store.append(self._fixed_floor_root_iter, [
ICON_FIXED_ROOMS,
f(_('Fixed Room {i}')), self, FixedController, i, False,
'', True
]))
recursive_generate_item_store_row_label(self._tree_model[root])
recursive_generate_item_store_row_label(
self._tree_model[self._fixed_floor_root_iter])
def add_scene_sub(self, level_name, scene_name):
file_name, ssb_file_name = self._create_scene_file(level_name,
scene_name,
'sss',
matching_ssb='00')
self._map_ssss[level_name][file_name] = self._tree_model.append(
self._sub_roots[level_name], [
'skytemple-e-ground-symbolic', scene_name, self, SsaController,
{
'map': level_name,
'file': file_name,
'type': 'sss',
'scripts': [ssb_file_name.split('/')[-1]]
}, False, '', True
])
recursive_generate_item_store_row_label(
self._tree_model[self._map_ssss[level_name][file_name]])
self.mark_as_modified(level_name, 'sss', file_name)
def create_new_level(self, new_name):
parent = self._other_node
if new_name[0] in self._sub_nodes.keys():
parent = self._sub_nodes[new_name[0]]
self._map_ssas[new_name] = {}
self._map_ssss[new_name] = {}
map_root = self._tree_model.append(parent, [
'skytemple-folder-symbolic', new_name, self, MapController,
new_name, False, '', True
])
self._map_scene_root[new_name] = map_root
ar = self._tree_model.append(map_root, [
'skytemple-folder-open-symbolic',
_('Acting (ssa)'), self, LsdController, new_name, False, '', True
])
self._acting_roots[new_name] = ar
sr = self._tree_model.append(map_root, [
'skytemple-folder-open-symbolic',
_('Sub (sss)'), self, SubController, new_name, False, '', True
])
self._sub_roots[new_name] = sr
recursive_generate_item_store_row_label(self._tree_model[parent])
def load_tree_items(self, item_store: TreeStore, root_node):
root = item_store.append(root_node, [
'skytemple-e-patch-symbolic', PATCHES, self, MainController, 0,
False, '', True
])
self._asm_iter = item_store.append(root, [
'skytemple-e-patch-symbolic',
_('ASM'), self, AsmController, 0, False, '', True
])
self._asm_special_procs = item_store.append(self._asm_iter, [
'skytemple-e-special-symbolic',
_('Special Process Effects'), self, SPEffectsController, 0, False,
'', True
])
self._asm_item_effects = item_store.append(self._asm_iter, [
'skytemple-e-item-symbolic',
_('Item Effects'), self, ItemEffectsController, 0, False, '', True
])
self._asm_move_effects = item_store.append(self._asm_iter, [
'skytemple-e-move-symbolic',
_('Move Effects'), self, MoveEffectsController, 0, False, '', True
])
self._asm_iter = item_store.append(root, [
'skytemple-e-patch-symbolic',
_('C/Rust'), self, CotController, 0, False, '', True
])
self._asm_iter = item_store.append(root, [
'skytemple-e-patch-symbolic',
_('Symbols'), self, PmdSkyDebugController, 0, False, '', True
])
recursive_generate_item_store_row_label(item_store[root])
self._tree_model = item_store
def add_scene_acting(self, level_name, scene_name):
file_name, ssb_file_name = self._create_scene_file(level_name,
scene_name,
'ssa',
matching_ssb='')
lsd_path = f'{SCRIPT_DIR}/{level_name}/{level_name.lower()}{LSD_EXT}'
if not self.project.file_exists(lsd_path):
self.project.create_new_file(lsd_path, FileType.LSD.new(),
FileType.LSD)
lsd: Lsd = self.project.open_file_in_rom(lsd_path, FileType.LSD)
lsd.entries.append(scene_name)
self._map_ssas[level_name][file_name] = self._tree_model.append(
self._acting_roots[level_name], [
'skytemple-e-ground-symbolic', scene_name, self, SsaController,
{
'map': level_name,
'file': file_name,
'type': 'ssa',
'scripts': [ssb_file_name.split('/')[-1]]
}, False, '', True
])
recursive_generate_item_store_row_label(
self._tree_model[self._map_ssas[level_name][file_name]])
self.mark_as_modified(level_name, 'ssa', file_name)
def load_tree_items(self, item_store: TreeStore, root_node):
self.dungeon_bin_context = self.project.open_file_in_rom(
DUNGEON_BIN_PATH,
FileType.DUNGEON_BIN,
static_data=self.project.get_rom_module().get_static_data(),
threadsafe=True)
with self.dungeon_bin_context as dungeon_bin:
self.list_of_wtes_dungeon_bin = dungeon_bin.get_files_with_ext(
WTE_FILE_EXT)
self.list_of_wtus_dungeon_bin = dungeon_bin.get_files_with_ext(
WTU_FILE_EXT)
self.list_of_zmappats_dungeon_bin = dungeon_bin.get_files_with_ext(
ZMAPPAT_FILE_EXT)
root = item_store.append(root_node, [
'skytemple-e-graphics-symbolic', MISC_GRAPHICS, self,
MainController, 0, False, '', True
])
self._tree_model = item_store
self._tree_level_iter = {}
self._tree_level_dungeon_iter = {}
# chr at the beginning:
for i, name in enumerate(self.list_of_chrs):
self._tree_level_iter[name] = item_store.append(
root, [
'skytemple-e-graphics-symbolic', name, self, ChrController,
name, False, '', True
])
sorted_entries = {}
for name in self.list_of_w16s:
sorted_entries[name] = False
for name in self.list_of_wtes:
sorted_entries[name] = True
sorted_entries = {
k: v
for k, v in sorted(sorted_entries.items(),
key=lambda item: item[0])
}
for i, (name, is_wte) in enumerate(sorted_entries.items()):
if not is_wte:
self._tree_level_iter[name] = item_store.append(
root, [
'skytemple-e-graphics-symbolic', name, self,
W16Controller,
self.list_of_w16s.index(name), False, '', True
])
else:
wtu_name = name[:-3] + WTU_FILE_EXT
if wtu_name not in self.list_of_wtus:
wtu_name = None
self._tree_level_iter[name] = item_store.append(
root, [
'skytemple-e-graphics-symbolic', name, self,
WteWtuController,
WteOpenSpec(name, wtu_name, False), False, '', True
])
# fonts at the end:
for i, name in enumerate(self.list_of_font_dats):
spec = FontOpenSpec(name, None, FontType.FONT_DAT)
self._tree_level_iter[spec.get_row_name()] = item_store.append(
root, [
'skytemple-e-graphics-symbolic',
spec.get_row_name(), self, FontController, spec, False, '',
True
])
for i, name in enumerate(self.list_of_font_sir0s):
spec = FontOpenSpec(name, None, FontType.FONT_SIR0)
self._tree_level_iter[spec.get_row_name()] = item_store.append(
root, [
'skytemple-e-graphics-symbolic',
spec.get_row_name(), self, FontController, spec, False, '',
True
])
for i, name in enumerate(self.list_of_banner_fonts):
for assoc in FONT_PAL_ASSOC:
if name == assoc[0]:
none_assoc = False
pal_name = assoc[1]
if pal_name not in self.list_of_bins:
pal_name = None
if not none_assoc or pal_name != None:
if pal_name == None:
none_assoc = True
spec = FontOpenSpec(name, pal_name,
FontType.BANNER_FONT)
self._tree_level_iter[
spec.get_row_name()] = item_store.append(
root, [
'skytemple-e-graphics-symbolic',
spec.get_row_name(), self, FontController,
spec, False, '', True
])
for i, name in enumerate(self.list_of_graphic_fonts):
pal_name = name[:-3] + PAL_FILE_EXT
if pal_name not in self.list_of_pals:
pal_name = None
spec = FontOpenSpec(name, pal_name, FontType.GRAPHIC_FONT)
self._tree_level_iter[spec.get_row_name()] = item_store.append(
root, [
'skytemple-e-graphics-symbolic',
spec.get_row_name(), self, GraphicFontController, spec,
False, '', True
])
# dungeon bin entries at the end:
for i, name in enumerate(
self.list_of_wtes_dungeon_bin): # type: ignore
wtu_name = name[:-3] + WTU_FILE_EXT
if name[:-3] + WTU_FILE_EXT not in self.list_of_wtus_dungeon_bin: # type: ignore
wtu_name = None
self._tree_level_dungeon_iter[name] = item_store.append(
root, [
'skytemple-e-graphics-symbolic', 'dungeon.bin:' + name,
self, WteWtuController,
WteOpenSpec(name, wtu_name, True), False, '', True
])
# zmappat at the end:
for i, name in enumerate(
self.list_of_zmappats_dungeon_bin): # type: ignore
self._tree_level_dungeon_iter[name] = item_store.append(
root, [
'skytemple-e-graphics-symbolic', 'dungeon.bin:' + name,
self, ZMappaTController, name, False, '', True
])
# cart removed at the end:
self._tree_level_iter[CART_REMOVED_NAME] = item_store.append(
root, [
'skytemple-e-graphics-symbolic', CART_REMOVED_NAME, self,
CartRemovedController, CART_REMOVED_NAME, False, '', True
])
recursive_generate_item_store_row_label(
self._tree_model[root]) # type: ignore
def load_tree_items(self, item_store: TreeStore, root_node):
# -> Script [main]
root = item_store.append(root_node, [
'skytemple-e-ground-symbolic', SCRIPT_SCENES, self, MainController,
0, False, '', True
])
self._root = root
self._tree_model = item_store
# -> Common [common]
item_store.append(root, [
'skytemple-e-script-symbolic', SCRIPT_SCRIPTS, self, SsbController,
0, False, '', True
])
sub_nodes = {
'S':
item_store.append(root, [
'skytemple-folder-symbolic',
_('S - System'), self, FolderController,
_('S - System'), False, '', True
]),
'T':
item_store.append(root, [
'skytemple-folder-symbolic',
_('T - Town'), self, FolderController,
_('T - Town'), False, '', True
]),
'D':
item_store.append(root, [
'skytemple-folder-symbolic',
_('D - Dungeon'), self, FolderController,
_('D - Dungeon'), False, '', True
]),
'G':
item_store.append(root, [
'skytemple-folder-symbolic',
_('G - Guild'), self, FolderController,
_('G - Guild'), False, '', True
]),
'H':
item_store.append(root, [
'skytemple-folder-symbolic',
_('H - Habitat'), self, FolderController,
_('H - Habitat'), False, '', True
]),
'P':
item_store.append(root, [
'skytemple-folder-symbolic',
_('P - Places'), self, FolderController,
_('P - Places'), False, '', True
]),
'V':
item_store.append(root, [
'skytemple-folder-symbolic',
_('V - Visual'), self, FolderController,
_('V - Visual'), False, '', True
])
}
# Other
other = item_store.append(root, [
'skytemple-folder-symbolic',
_('Others'), self, FolderController, None, False, '', True
])
self._other_node = other
self._sub_nodes = sub_nodes
for i, map_obj in enumerate(
self.script_engine_file_tree['maps'].values()):
parent = other
if map_obj['name'][0] in sub_nodes.keys():
parent = sub_nodes[map_obj['name'][0]]
self._map_ssas[map_obj['name']] = {}
self._map_ssss[map_obj['name']] = {}
# -> (Map Name) [map]
map_root = item_store.append(parent, [
'skytemple-folder-symbolic', map_obj['name'], self,
MapController, map_obj['name'], False, '', True
])
self._map_scene_root[map_obj['name']] = map_root
if map_obj['enter_sse'] is not None:
# -> Enter [sse]
self._map_sse[map_obj['name']] = item_store.append(
map_root, [
'skytemple-e-ground-symbolic',
_('Enter (sse)'), self, SsaController, {
'map': map_obj['name'],
'file':
f"{SCRIPT_DIR}/{map_obj['name']}/{map_obj['enter_sse']}",
'type': 'sse',
'scripts': map_obj['enter_ssbs'].copy()
}, False, '', True
])
# -> Acting Scripts [lsd]
acting_root = item_store.append(map_root, [
'skytemple-folder-open-symbolic',
_('Acting (ssa)'), self, LsdController, map_obj['name'], False,
'', True
])
self._acting_roots[map_obj['name']] = acting_root
for ssa, ssb in map_obj['ssas']:
stem = ssa[:-len(SSA_EXT)]
# -> Scene [ssa]
filename = f"{SCRIPT_DIR}/{map_obj['name']}/{ssa}"
self._map_ssas[map_obj['name']][filename] = item_store.append(
acting_root, [
'skytemple-e-ground-symbolic', stem, self,
SsaController, {
'map': map_obj['name'],
'file': filename,
'type': 'ssa',
'scripts': [ssb]
}, False, '', True
])
# -> Sub Scripts [sub]
sub_root = item_store.append(map_root, [
'skytemple-folder-open-symbolic',
_('Sub (sss)'), self, SubController, map_obj['name'], False,
'', True
])
self._sub_roots[map_obj['name']] = sub_root
for sss, ssbs in map_obj['subscripts'].items():
stem = sss[:-len(SSS_EXT)]
# -> Scene [sss]
filename = f"{SCRIPT_DIR}/{map_obj['name']}/{sss}"
self._map_ssss[map_obj['name']][filename] = item_store.append(
sub_root, [
'skytemple-e-ground-symbolic', stem, self,
SsaController, {
'map': map_obj['name'],
'file': filename,
'type': 'sss',
'scripts': ssbs.copy()
}, False, '', True
])
recursive_generate_item_store_row_label(self._tree_model[root])
def change_floor_count(self, dungeon_id,
number_floors_new): #TODO: Unchanged
"""
This will update the floor count for the given dungeon:
- Will add or remove floors from the dungeon's mappa entry, starting at the end of this dungeon's floor
based on the current floor count for this dungeon
- Update the dungeon's data entry (floor count + total floor count in group)
- For all other dungeons in the same group: Update data entries (total floor count + start offset)
- Regenerate the UI in SkyTemple (dungeon tree)
"""
dungeon_definitions = self.get_dungeon_list()
is_group: Union[False, DungeonGroup] = False
for dungeon_or_group in self.load_dungeons():
if dungeon_or_group == dungeon_id:
break
elif isinstance(dungeon_or_group, DungeonGroup):
if dungeon_id in dungeon_or_group.dungeon_ids:
is_group = dungeon_or_group
break
mappa_index = dungeon_definitions[dungeon_id].mappa_index
floor_offset = dungeon_definitions[dungeon_id].start_after
number_floors_old = dungeon_definitions[dungeon_id].number_floors
floor_list = self.get_mappa().floor_lists[mappa_index]
floors_added = number_floors_new - number_floors_old
# Update Mappa
if floors_added == 0:
return # nothing to do
if floors_added < 0:
# We removed floors
for _ in range(0, -floors_added):
del floor_list[floor_offset + number_floors_new]
else:
# We added floors
last_floor_xml = floor_list[floor_offset + number_floors_old -
1].to_xml()
for i in range(0, floors_added):
floor_list.insert(floor_offset + number_floors_old + i,
MappaFloor.from_xml(last_floor_xml))
# Update floor ranks
self.extend_nb_floors_ranks(
dungeon_id, floor_offset + number_floors_old, floors_added,
self.get_floor_rank(dungeon_id,
floor_offset + number_floors_old - 1))
if self.has_floor_ranks():
self.project.mark_as_modified(FLOOR_RANKS)
# Update mission forbidden
self.extend_nb_floors_mf(
dungeon_id, floor_offset + number_floors_old, floors_added,
self.get_floor_mf(dungeon_id,
floor_offset + number_floors_old - 1))
if self.has_mission_forbidden():
self.project.mark_as_modified(FLOOR_MISSION_FORBIDDEN)
# Update dungeon data
dungeon_definitions[dungeon_id].number_floors = number_floors_new
if is_group:
new_total_floor_count = sum([
dungeon_definitions[x].number_floors
for x in is_group.dungeon_ids
])
dungeon_definitions[
dungeon_id].number_floors_in_group = new_total_floor_count
for dungeon_in_group in (x for x in is_group.dungeon_ids
if x != dungeon_id):
# Update dungeon data of group floors
if dungeon_definitions[
dungeon_in_group].start_after > dungeon_definitions[
dungeon_id].start_after:
dungeon_definitions[
dungeon_in_group].start_after += floors_added
dungeon_definitions[
dungeon_in_group].number_floors_in_group = new_total_floor_count
else:
dungeon_definitions[
dungeon_id].number_floors_in_group = number_floors_new
# Re-count floors
for i, floor in enumerate(floor_list):
floor.layout.floor_number = i + 1
# Mark as changed
self.mark_dungeon_as_modified(dungeon_id, True)
self.save_dungeon_list(dungeon_definitions)
if is_group:
for dungeon_in_group in is_group.dungeon_ids:
self._regenerate_dungeon_floors(
dungeon_in_group,
dungeon_definitions[dungeon_in_group].start_after)
else:
self._regenerate_dungeon_floors(dungeon_id, floor_offset)
recursive_generate_item_store_row_label(
self._tree_model[self._root_iter])
