def draw_maps_main(): global monster_bin_pack_file, monster_md os.makedirs(output_dir, exist_ok=True) rom = NintendoDSRom.fromFile(os.path.join(base_dir, 'skyworkcopy_edit.nds')) monster_bin_pack_file = FileType.BIN_PACK.deserialize( rom.getFileByName('MONSTER/monster.bin')) monster_md = FileType.MD.deserialize( rom.getFileByName('BALANCE/monster.md')) script_info = load_script_files(get_rom_folder(rom, SCRIPT_DIR)) map_bg_entry_level_list = FileType.BG_LIST_DAT.deserialize( rom.getFileByName('MAP_BG/bg_list.dat')).level for script_map in script_info['maps'].values(): # Map BGs are NOT *actually* mapped 1:1 to scripts. They are loaded via Opcode. However it turns out, using the BPL name # is an easy way to map them. map_bg_entry = next(x for x in map_bg_entry_level_list if x.bpl_name == script_map['name']) if script_map['enter_sse'] is not None: process( rom, map_bg_entry, script_map['name'], SCRIPT_DIR + '/' + script_map['name'] + '/' + script_map['enter_sse']) for ssa, _ in script_map['ssas']: process(rom, map_bg_entry, script_map['name'], SCRIPT_DIR + '/' + script_map['name'] + '/' + ssa) for sss in script_map['subscripts'].keys(): process(rom, map_bg_entry, script_map['name'], SCRIPT_DIR + '/' + script_map['name'] + '/' + sss)
async def main(executor): output_dir = os.path.join(os.path.dirname(__file__), 'dbg_output') base_dir = os.path.join(os.path.dirname(__file__), '..', '..', '..', '..', '..') os.makedirs(output_dir, exist_ok=True) rom = NintendoDSRom.fromFile( os.path.join(base_dir, 'skyworkcopy_us_unpatched.nds')) script_info = load_script_files(get_rom_folder(rom, SCRIPT_DIR)) # total, opening. decompiling, parsing, compiling, serializing times: List[Tuple[float, float, float, float, float, float]] = [] static_data = Pmd2XmlReader.load_default(for_version='EoS_NA') awaitables = [] for i, file_name in enumerate(get_files_from_rom_with_extension( rom, 'ssb')): # TODO: Those scripts fail for JP. if file_name in [ 'SCRIPT/D42P21A/enter23.ssb', 'SCRIPT/D73P11A/us0303.ssb', 'SCRIPT/D73P11A/us0305.ssb', 'SCRIPT/D73P11A/us2003.ssb', 'SCRIPT/D73P11A/us2005.ssb', 'SCRIPT/D73P11A/us2103.ssb', 'SCRIPT/D73P11A/us2105.ssb', 'SCRIPT/D73P11A/us2203.ssb', 'SCRIPT/D73P11A/us2205.ssb', 'SCRIPT/D73P11A/us2303.ssb', 'SCRIPT/D73P11A/us2305.ssb' ]: continue # Run multiple in parallel with asyncio executors. awaitables.append( loop.run_in_executor(executor, process_single, file_name, times, static_data, output_dir, rom)) pending = awaitables while len(pending) > 0: done, pending = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED) # to raise exceptions of tasks back to main loop: for fut in done: try: fut.result() except Exception: loop.stop() with poison_lock: poison_container[0] = True raise times_structured = list(zip(*times)) print_table_row("", "TOTAL", "OPENING", "DECOMPILING", "PARSING", "COMPILING", "SERIALIZING") print_table_row(*(["==========="] * 7)) print_table_row("TOTAL:", *[round(sum(t), 2) for t in times_structured]) print_table_row("AVG:", *[round(sum(t) / len(t), 2) for t in times_structured]) print_table_row("MAX:", *[round(max(t), 2) for t in times_structured]) print_table_row("MIN:", *[round(min(t), 2) for t in times_structured])
def main(): os.makedirs(output_dir, exist_ok=True) rom = NintendoDSRom.fromFile(os.path.join(base_dir, 'skyworkcopy.nds')) script_info = load_script_files(get_rom_folder(rom, SCRIPT_DIR)) for script_map in script_info['maps'].values(): if script_map['enter_sse'] is not None: process(rom, SCRIPT_DIR + '/' + script_map['name'] + '/', script_map['enter_sse'], script_map['enter_ssbs']) for ssa, ssb in script_map['ssas']: process(rom, SCRIPT_DIR + '/' + script_map['name'] + '/', ssa, [ssb]) for sss, ssb in script_map['subscripts'].items(): process(rom, SCRIPT_DIR + '/' + script_map['name'] + '/', sss, ssb)
def main(): os.makedirs(output_dir, exist_ok=True) rom = NintendoDSRom.fromFile(os.path.join(base_dir, 'skyworkcopy.nds')) script_info = load_script_files(get_rom_folder(rom, SCRIPT_DIR)) for script_map in script_info['maps'].values(): # Map BGs are NOT *actually* mapped 1:1 to scripts. They are loaded via Opcode. However it turns out, using the BPL name # is an easy way to map them. if script_map['enter_sse'] is not None: process( rom, script_map['name'], SCRIPT_DIR + '/' + script_map['name'] + '/' + script_map['enter_sse']) for ssa, _ in script_map['ssas']: process(rom, script_map['name'], SCRIPT_DIR + '/' + script_map['name'] + '/' + ssa) for sss in script_map['subscripts'].keys(): process(rom, script_map['name'], SCRIPT_DIR + '/' + script_map['name'] + '/' + sss)
def draw_maps(rom: NintendoDSRom, map_dir, scriptdata: Pmd2ScriptData): script_info = load_script_files(get_rom_folder(rom, SCRIPT_DIR)) count = len(script_info['maps']) for i, script_map in enumerate(script_info['maps'].values()): if script_map['enter_sse'] is not None: draw_scenes_for(rom, i, count, os.path.join(map_dir, script_map['name'], script_map['enter_sse']), script_map['name'], script_map['enter_sse'], SCRIPT_DIR + '/' + script_map['name'] + '/' + script_map['enter_sse'], scriptdata) for ssa, _ in script_map['ssas']: draw_scenes_for(rom, i, count, os.path.join(map_dir, script_map['name'], ssa), script_map['name'], ssa, SCRIPT_DIR + '/' + script_map['name'] + '/' + ssa, scriptdata) for sss in script_map['subscripts'].keys(): draw_scenes_for(rom, i, count, os.path.join(map_dir, script_map['name'], sss), script_map['name'], sss, SCRIPT_DIR + '/' + script_map['name'] + '/' + sss, scriptdata)
def load_script_files(self) -> ScriptFiles: return load_script_files(get_rom_folder(self._rom, SCRIPT_DIR)) # type: ignore
# # You should have received a copy of the GNU General Public License # along with SkyTemple. If not, see <https://www.gnu.org/licenses/>. # mypy: ignore-errors import os from ndspy.rom import NintendoDSRom from skytemple_files.common.script_util import load_script_files, SCRIPT_DIR from skytemple_files.common.util import get_rom_folder from skytemple_files.script.lsd.handler import LsdHandler base_dir = os.path.join(os.path.dirname(__file__), '..', '..', '..', '..', '..') rom = NintendoDSRom.fromFile(os.path.join(base_dir, 'skyworkcopy.nds')) script_info = load_script_files(get_rom_folder(rom, SCRIPT_DIR)) for map_name, map in script_info['maps'].items(): if map['lsd'] is not None: lsd_name = SCRIPT_DIR + '/' + map_name + '/' + map['lsd'] bin_before = rom.getFileByName(lsd_name) lsd = LsdHandler.deserialize(bin_before) print(f"{lsd_name}: {lsd.entries}") bin_after = LsdHandler.serialize(lsd) assert bin_before == bin_after
def get_rom_folder(self, path): return get_rom_folder(self._rom, path)
def main(): output_dir = os.path.join(os.path.dirname(__file__), 'dbg_output') base_dir = os.path.join(os.path.dirname(__file__), '..', '..', '..', '..', '..') os.makedirs(output_dir, exist_ok=True) rom = NintendoDSRom.fromFile(os.path.join(base_dir, 'skyworkcopy.nds')) script_info = load_script_files(get_rom_folder(rom, SCRIPT_DIR)) # total, opening. decompiling, parsing, compiling, serializing times: List[Tuple[float, float, float, float, float, float]] = [] for i, file_name in enumerate(get_files_from_rom_with_extension( rom, 'ssb')): print(file_name) out_file_name = os.path.join(output_dir, file_name.replace('/', '_') + '.ssbs') time_before = time.time() bin_before = rom.getFileByName(file_name) time_opening = time.time() ssb_before = SsbHandler.deserialize(bin_before) ssb_script, source_map_before = ssb_before.to_ssb_script() time_decompiling = time.time() for pos_mark in source_map_before.get_position_marks__direct(): print(pos_mark) with open(out_file_name, 'w') as f: f.write(ssb_script) # Test the compiling and writing, by compiling the model, writing it to binary, and then loading it again, # and checking the generated ssb script. compiler = ScriptCompiler(Pmd2XmlReader.load_default()) time_parsing = 0 def callback_after_parsing(): nonlocal time_parsing time_parsing = time.time() ssb_after, source_map_after = compiler.compile_ssbscript( ssb_script, callback_after_parsing) time_compiling = time.time() bin_after = SsbHandler.serialize(ssb_after) time_serializing = time.time() ssb_after_after = SsbHandler.deserialize(bin_after) ssb_script_after = ssb_after_after.to_ssb_script()[0] with open('/tmp/diff1.ssb', 'w') as f: f.write(ssb_script) with open('/tmp/diff2.ssb', 'w') as f: f.write(ssb_script_after) assert (ssb_script == ssb_script_after) assert (source_map_before == source_map_after) times.append(( time_serializing - time_before, # total time_opening - time_before, # opening. time_decompiling - time_opening, # decompiling, time_parsing - time_decompiling, # parsing, time_compiling - time_parsing, # compiling, time_serializing - time_compiling, # serializing )) times_structured = list(zip(*times)) print_table_row("", "TOTAL", "OPENING", "DECOMPILING", "PARSING", "COMPILING", "SERIALIZING") print_table_row(*(["==========="] * 7)) print_table_row("TOTAL:", *[round(sum(t), 2) for t in times_structured]) print_table_row("AVG:", *[round(sum(t) / len(t), 2) for t in times_structured]) print_table_row("MAX:", *[round(max(t), 2) for t in times_structured]) print_table_row("MIN:", *[round(min(t), 2) for t in times_structured])