import os import random import re import sys import time import functools from io import BytesIO import tools from fileutils import * from dolreader import DolFile, SectionCountFullError try: import chardet except ImportError as IE: print(IE) sys.exit(1) def timer(func): @functools.wraps(func) def wrapper(*args, **kwargs): start = time.perf_counter() value = func(*args, **kwargs) end = time.perf_counter() print(tools.color_text(f'\n :: Completed in {(end - start):0.4f} seconds!\n', defaultColor=tools.TGREENLIT)) return value return wrapper class InvalidGeckoCodeError(Exception): pass class GCT(object): def __init__(self, f): self.codeList = BytesIO(f.read()) self.rawLineCount = tools.stream_size(self.codeList) >> 3 self.lineCount = self.rawLineCount - 2 self.size = tools.stream_size(self.codeList) f.seek(0) @staticmethod def determine_codelength(codetype, info: bytes) -> int: if codetype.startswith(b'\x06'): bytelength = int.from_bytes(info, byteorder='big', signed=False) padding = get_alignment(bytelength, 8) return 0x8 + bytelength + padding elif (codetype.startswith(b'\x08') or codetype.startswith(b'\x09') or codetype.startswith(b'\x18') or codetype.startswith(b'\x18')): return 0x16 elif (codetype.startswith(b'\xC2') or codetype.startswith(b'\xC4') or codetype.startswith(b'\xC3') or codetype.startswith(b'\xC5') or codetype.startswith(b'\xD2') or codetype.startswith(b'\xD4') or codetype.startswith(b'\xD3') or codetype.startswith(b'\xD5')): return 0x8 + (int.from_bytes(info, byteorder='big', signed=False) << 3) elif (codetype.startswith(b'\xF2') or codetype.startswith(b'\xF3') or codetype.startswith(b'\xF4') or codetype.startswith(b'\xF5')): return 0x8 + (int.from_bytes(info[:2], byteorder='big', signed=False) << 3) elif codetype.startswith(b'\xF6'): return 0x8 + (int.from_bytes(info[:4], byteorder='big', signed=False) << 3) else: return 0x8 def optimize_codelist(self, dolFile: DolFile): codelist = b'\x00\xD0\xC0\xDE'*2 skipcodes = 0 self.codeList.seek(8) while codetype := self.codeList.read(4): info = self.codeList.read(4) address = 0x80000000 | (int.from_bytes(codetype, byteorder='big', signed=False) & 0x01FFFFFF) try: if skipcodes <= 0: if (codetype.startswith(b'\x00') or codetype.startswith(b'\x01') or codetype.startswith(b'\x10') or codetype.startswith(b'\x11')): dolFile.seek(address) counter = int.from_bytes(info[:-2], byteorder='big', signed=False) value = info[2:] while counter + 1 > 0: dolFile.write(value[1:]) counter -= 1 continue elif (codetype.startswith(b'\x02') or codetype.startswith(b'\x03') or codetype.startswith(b'\x12') or codetype.startswith(b'\x13')): dolFile.seek(address) counter = int.from_bytes(info[:-2], byteorder='big', signed=False) value = info[2:] while counter + 1 > 0: dolFile.write(value) counter -= 1 continue elif (codetype.startswith(b'\x04') or codetype.startswith(b'\x05') or codetype.startswith(b'\x14') or codetype.startswith(b'\x15')): dolFile.seek(address) dolFile.write(info) continue elif (codetype.startswith(b'\x06') or codetype.startswith(b'\x07') or codetype.startswith(b'\x16') or codetype.startswith(b'\x17')): dolFile.seek(address) arraylength = int.from_bytes(info, byteorder='big', signed=False) padding = get_alignment(arraylength, 8) while arraylength > 0: value = self.codeList.read(1) dolFile.write(value) arraylength -= 1 self.codeList.seek(padding, 1) continue elif (codetype.startswith(b'\x08') or codetype.startswith(b'\x09') or codetype.startswith(b'\x18') or codetype.startswith(b'\x19')): dolFile.seek(address) value = int.from_bytes(info, byteorder='big', signed=False) data = read_uint16(self.codeList) size = data & 0x3000 counter = data & 0xFFF address_increment = read_uint16(self.codeList) value_increment = read_uint32(self.codeList) while counter + 1 > 0: if size == 0: write_ubyte(dolFile, value) dolFile.seek(-1, 1) elif size == 1: write_uint16(dolFile, value) dolFile.seek(-2, 1) elif size == 2: write_uint32(dolFile, value) dolFile.seek(-4, 1) else: raise ValueError('Size type {} does not match 08 codetype specs'.format(size)) dolFile.seek(address_increment, 1) value += value_increment counter -= 1 if value > 0xFFFFFFFF: value -= 0x100000000 continue elif (codetype.startswith(b'\xC6') or codetype.startswith(b'\xC7') or codetype.startswith(b'\xC6') or codetype.startswith(b'\xC7')): dolFile.seek(address) dolFile.insertBranch(int.from_bytes(info, byteorder='big', signed=False), dolFile.tell()) continue if codetype.hex().startswith('2') or codetype.hex().startswith('3'): skipcodes += 1 elif codetype.startswith(b'\xE0'): skipcodes -= 1 elif codetype.startswith(b'\xF0'): codelist += b'\xF0\x00\x00\x00\x00\x00\x00\x00' break self.codeList.seek(-8, 1)*5 length = GCT.determine_codelength(codetype, info) while length > 0: codelist += self.codeList.read(1) length -= 1 except RuntimeError: self.codeList.seek(-8, 1) length = GCT.determine_codelength(codetype, info) codelist += self.codeList.read(length) self.codeList = BytesIO(codelist) self.size = len(self.codeList.getbuffer()) class CodeHandler(object): def __init__(self, f): self._rawData = BytesIO(f.read()) '''Get codelist pointer''' self._rawData.seek(0xFA) codelistUpper = self._rawData.read(2).hex() self._rawData.seek(0xFE) codelistLower = self._rawData.read(2).hex() self.codeListPointer = int(codelistUpper[2:] + codelistLower[2:], 16) self.handlerLength = tools.stream_size(self._rawData) self.initAddress = 0x80001800 self.startAddress = 0x800018A8 self.wiiVIHook = b'\x7C\xE3\x3B\x78\x38\x87\x00\x34\x38\xA7\x00\x38\x38\xC7\x00\x4C' self.gcnVIHook = b'\x7C\x03\x00\x34\x38\x83\x00\x20\x54\x85\x08\x3C\x7C\x7F\x2A\x14\xA0\x03\x00\x00\x7C\x7D\x2A\x14\x20\xA4\x00\x3F\xB0\x03\x00\x00' self.wiiGXDrawHook = b'\x3C\xA0\xCC\x01\x38\x00\x00\x61\x3C\x80\x45\x00\x98\x05\x80\x00' self.gcnGXDrawHook = b'\x38\x00\x00\x61\x3C\xA0\xCC\x01\x3C\x80\x45\x00\x98\x05\x80\x00' self.wiiPADHook = b'\x3A\xB5\x00\x01\x3A\x73\x00\x0C\x2C\x15\x00\x04\x3B\x18\x00\x0C' self.gcnPADHook = b'\x3A\xB5\x00\x01\x2C\x15\x00\x04\x3B\x18\x00\x0C\x3B\xFF\x00\x0C' self.allocation = None self.hookAddress = None self.hookType = None self.geckoCodes = None self.includeAll = False self.optimizeList = False if self.handlerLength < 0x900: self.type = "Mini" else: self.type = "Full" f.seek(0) def parse_input(self, geckoText) -> str: with open(r'{}'.format(geckoText), 'rb') as gecko: result = chardet.detect(gecko.read()) encodeType = result['encoding'] with open(r'{}'.format(geckoText), 'r', encoding=encodeType) as gecko: geckoCodes = '' state = None for line in gecko.readlines(): if line in ('', '\n'): continue if state is None: if line.startswith('$') or line.startswith('['): state = 'Dolphin' else: state = 'OcarinaM' try: if state == 'OcarinaM': if self.includeAll: geckoLine = re.findall(r'[A-F0-9]{8}[\t\f ][A-F0-9]{8}', line, re.IGNORECASE)[0] else: geckoLine = re.findall(r'(?:\*\s*)([A-F0-9]{8}[\t\f ][A-F0-9]{8})', line, re.IGNORECASE)[0] else: geckoLine = re.findall(r'(? int: b1 = key & 0xFF b2 = (key >> 8) & 0xFF b3 = (key >> 16) & 0xFF b4 = (key >> 24) & 0xFF b3 ^= b4 b2 ^= b3 b1 ^= b2 return (b1 << 24) | (b2 << 16) | (b3 << 8) | b4 def encrypt_codes(self, key: int): self.geckoCodes.codeList.seek(0) i = 0 while True: try: packet = read_uint32(self.geckoCodes.codeList) self.geckoCodes.codeList.seek(-4, 1) write_uint32(self.geckoCodes.codeList, (packet^key) & 0xFFFFFFFF) key += (i << 3) & 0xFFFFFFFF if key > 0xFFFFFFFF: key -= 0x100000000 i += 1 except: break def find_variable_data(self, variable) -> int: self._rawData.seek(0) if self._rawData.read(4) == variable: return self._rawData.tell() - 4 while sample := self._rawData.read(4): if sample == variable: return self._rawData.tell() - 4 return None def set_hook_instruction(self, dolFile: DolFile, address: int, varOffset: int, lk=0): self._rawData.seek(varOffset) dolFile.seek(address) ppc = read_uint32(dolFile) if (((ppc >> 24) & 0xFF) > 0x47 and ((ppc >> 24) & 0xFF) < 0x4C): to = dolFile.extract_branch_addr(address) write_uint32(self._rawData, (to - (self.initAddress + varOffset)) & 0x3FFFFFD | 0x48000000 | lk) else: write_uint32(self._rawData, ppc) def set_variables(self, dolFile: DolFile): varOffset = self.find_variable_data(b'\x00\xDE\xDE\xDE') if varOffset is None: raise RuntimeError(tools.color_text("Variable codehandler data not found\n", defaultColor=tools.TREDLIT)) self.set_hook_instruction(dolFile, self.hookAddress, varOffset, 0) self._rawData.seek(varOffset + 4) write_uint32(self._rawData, ((self.hookAddress + 4) - (self.initAddress + (varOffset + 4))) & 0x3FFFFFD | 0x48000000 | 0) class KernelLoader(object): def __init__(self, f, cli: tools.CommandLineParser=None): self._rawData = BytesIO(f.read()) self._initDataList = None self._gpModDataList = None self._gpDiscDataList = None self._gpKeyAddrList = None self._cli = cli self.patchJob = None self.initAddress = None self.protect = False self.verbosity = 0 self.quiet = False self.encrypt = False def error(self, msg: str, exit=True): if self._cli is not None: self._cli.error(msg, exit) else: print(msg) if exit: sys.exit(1) def set_variables(self, entryPoint: list, baseOffset: int=0): self._rawData.seek(0) if self._gpModDataList is None: return while sample := self._rawData.read(2): if sample == b'GH': self._rawData.seek(-2, 1) write_uint16(self._rawData, self._gpModDataList[0]) elif sample == b'GL': self._rawData.seek(-2, 1) write_uint16(self._rawData, baseOffset + self._gpModDataList[1]) elif sample == b'IH': self._rawData.seek(-2, 1) write_uint16(self._rawData, entryPoint[0]) elif sample == b'IL': self._rawData.seek(-2, 1) write_uint16(self._rawData, entryPoint[1]) elif sample == b'KH': self._rawData.seek(-2, 1) write_uint16(self._rawData, self._gpKeyAddrList[0]) elif sample == b'KL': self._rawData.seek(-2, 1) write_uint16(self._rawData, baseOffset + self._gpKeyAddrList[1]) def complete_data(self, codeHandler: CodeHandler, initpoint: list): _upperAddr, _lowerAddr = ((self.initAddress >> 16) & 0xFFFF, self.initAddress & 0xFFFF) _key = random.randrange(0x100000000) self._rawData.seek(0) while sample := self._rawData.read(4): if sample == b'HEAP': #Found keyword "HEAP". Goes with the resize of the heap self._rawData.seek(-4, 1) gpModInfoOffset = self._rawData.tell() if _lowerAddr + gpModInfoOffset > 0x7FFF: #Absolute addressing gpModUpperAddr = _upperAddr + 1 else: gpModUpperAddr = _upperAddr if codeHandler.allocation == None: codeHandler.allocation = (codeHandler.handlerLength + codeHandler.geckoCodes.size + 7) & -8 write_uint32(self._rawData, codeHandler.allocation) elif sample == b'LSIZ': #Found keyword "LSIZ". Goes with the size of the loader self._rawData.seek(-4, 1) write_uint32(self._rawData, len(self._rawData.getbuffer())) elif sample == b'HSIZ': #Found keyword "HSIZ". Goes with the size of the codeHandler self._rawData.seek(-4, 1) write_sint32(self._rawData, codeHandler.handlerLength) elif sample == b'CSIZ': #Found keyword "CSIZ". Goes with the size of the codes self._rawData.seek(-4, 1) write_sint32(self._rawData, codeHandler.geckoCodes.size) elif sample == b'HOOK': #Found keyword "HOOK". Goes with the codehandler hook self._rawData.seek(-4, 1) write_uint32(self._rawData, codeHandler.hookAddress) elif sample == b'CRPT': #Found keyword "CRPT". Boolean of the encryption self._rawData.seek(-4, 1) write_bool(self._rawData, self.encrypt, 4) elif sample == b'CYPT': #Found keyword "CYPT". Encryption Key self._rawData.seek(-4, 1) gpKeyOffset = self._rawData.tell() if _lowerAddr + gpKeyOffset > 0x7FFF: #Absolute addressing gpKeyUpperAddr = _upperAddr + 1 else: gpKeyUpperAddr = _upperAddr write_uint32(self._rawData, CodeHandler.encrypt_key(_key)) self._gpModDataList = (gpModUpperAddr, gpModInfoOffset) self._gpKeyAddrList = (gpKeyUpperAddr, gpKeyOffset) self.set_variables(initpoint, _lowerAddr) if self.encrypt: codeHandler.encrypt_codes(_key) def patch_arena(self, codeHandler: CodeHandler, dolFile: DolFile): self.complete_data(codeHandler, [(dolFile.entryPoint >> 16) & 0xFFFF, dolFile.entryPoint & 0xFFFF]) self._rawData.seek(0, 2) self._rawData.write(codeHandler._rawData.getvalue() + codeHandler.geckoCodes.codeList.getvalue()) self._rawData.seek(0) _kernelData = self._rawData.getvalue() try: dolFile.append_text_sections([(_kernelData, self.initAddress)]) except SectionCountFullError: try: dolFile.append_data_sections([(_kernelData, self.initAddress)]) except SectionCountFullError: self.error(tools.color_text('There are no unused sections left for GeckoLoader to use!\n', defaultColor=tools.TREDLIT)) dolFile.entryPoint = self.initAddress def patch_legacy(self, codeHandler: CodeHandler, dolFile: DolFile): codeHandler._rawData.seek(0) codeHandler.geckoCodes.codeList.seek(0) _handlerData = codeHandler._rawData.getvalue() + codeHandler.geckoCodes.codeList.getvalue() try: dolFile.append_text_sections([(_handlerData, codeHandler.initAddress)]) except SectionCountFullError: try: dolFile.append_data_sections([(_handlerData, codeHandler.initAddress)]) except SectionCountFullError: self.error(tools.color_text('There are no unused sections left for GeckoLoader to use!\n', defaultColor=tools.TREDLIT)) def protect_game(self, codeHandler: CodeHandler): _oldpos = codeHandler.geckoCodes.codeList.tell() protectdata = (b'\xC0\x00\x00\x00\x00\x00\x00\x17', b'\x7C\x08\x02\xA6\x94\x21\xFF\x70', b'\x90\x01\x00\x08\xBC\x61\x00\x0C', b'\x48\x00\x00\x0D\x00\xD0\xC0\xDE', b'\x00\xD0\xDE\xAD\x7F\xE8\x02\xA6', b'\x3B\xDF\x00\x08\x3C\x60\x80\x00', b'\x38\x80\x11\x00\x38\xA0\x00\x00', b'\x60\x63\x1E\xF8\x7C\x89\x03\xA6', b'\x38\x80\x00\x00\x7D\x03\x22\x14', b'\x54\xE9\x06\x3E\x89\x08\x00\x08', b'\x7D\x3F\x48\xAE\x38\xE7\x00\x01', b'\x7C\x08\x48\x40\x41\x82\x00\x0C', b'\x60\xA7\x00\x00\x48\x00\x00\x04', b'\x54\xE8\x06\x3E\x28\x08\x00\x03', b'\x41\x81\x00\x10\x38\x84\x00\x01', b'\x42\x00\xFF\xCC\x48\x00\x00\x2C', b'\x38\xA0\x00\x08\x7C\x84\x1A\x14', b'\x7C\xA9\x03\xA6\x38\x60\x00\x00', b'\x38\x84\xFF\xFF\x54\x66\x07\xBE', b'\x7C\xDE\x30\xAE\x38\x63\x00\x01', b'\x9C\xC4\x00\x01\x42\x00\xFF\xF0', b'\xB8\x61\x00\x0C\x80\x01\x00\x08', b'\x38\x21\x00\x90\x7C\x08\x03\xA6', b'\x4E\x80\x00\x20\x00\x00\x00\x00') codeHandler.geckoCodes.codeList.seek(-8, 2) for chunk in protectdata: codeHandler.geckoCodes.codeList.write(chunk) codeHandler.geckoCodes.codeList.write(b'\xF0\x00\x00\x00\x00\x00\x00\x00') codeHandler.geckoCodes.codeList.seek(0, 2) codeHandler.geckoCodes.size = codeHandler.geckoCodes.codeList.tell() codeHandler.geckoCodes.codeList.seek(_oldpos) @timer def build(self, gctFile, dolFile: DolFile, codeHandler: CodeHandler, tmpdir, dump): oldStart = dolFile.entryPoint '''Initialize our codes''' if '.' in gctFile: if os.path.splitext(gctFile)[1].lower() == '.txt': with open(os.path.join(tmpdir, 'gct.bin'), 'wb+') as temp: temp.write(bytes.fromhex('00D0C0DE'*2 + codeHandler.parse_input(gctFile) + 'F000000000000000')) temp.seek(0) codeHandler.geckoCodes = GCT(temp) elif os.path.splitext(gctFile)[1].lower() == '.gct': with open(gctFile, 'rb') as gct: codeHandler.geckoCodes = GCT(gct) else: with open(os.path.join(tmpdir, 'gct.bin'), 'wb+') as temp: temp.write(b'\x00\xD0\xC0\xDE'*2) for file in os.listdir(gctFile): if os.path.isfile(os.path.join(gctFile, file)): if os.path.splitext(file)[1].lower() == '.txt': temp.write(bytes.fromhex(codeHandler.parse_input(os.path.join(gctFile, file)))) elif os.path.splitext(file)[1].lower() == '.gct': with open(os.path.join(gctFile, file), 'rb') as gct: temp.write(gct.read()[8:-8]) else: print(tools.color_text(f' :: HINT: {file} is not a .txt or .gct file', defaultColor=tools.TYELLOWLIT)) temp.write(b'\xF0\x00\x00\x00\x00\x00\x00\x00') temp.seek(0) codeHandler.geckoCodes = GCT(temp) if codeHandler.geckoCodes is None: self.error(tools.color_text('Valid codelist not found. Please provide a .txt/.gct file, or a folder of .txt/.gct files\n', defaultColor=tools.TREDLIT)) if self.protect and self.patchJob == "ARENA": self.protect_game(codeHandler) if self.patchJob == 'AUTO': if codeHandler.initAddress + codeHandler.handlerLength + codeHandler.geckoCodes.size > 0x80002FFF: self.patchJob = 'ARENA' else: self.patchJob = 'LEGACY' '''Get entrypoint (or BSS midpoint) for insert''' if self.initAddress: try: dolFile.resolve_address(self.initAddress) print(tools.color_text(f'\n :: WARNING: Init address specified for GeckoLoader (0x{self.initAddress:X}) clobbers existing dol sections', defaultColor=tools.TYELLOW)) except RuntimeError: pass else: self.initAddress = dolFile.seek_nearest_unmapped(dolFile.bssAddress, len(self._rawData.getbuffer()) + codeHandler.handlerLength + codeHandler.geckoCodes.size) self._rawData.seek(0) if codeHandler.optimizeList: codeHandler.geckoCodes.optimize_codelist(dolFile) '''Is codelist optimized away?''' if codeHandler.geckoCodes.codeList.getvalue() == b'\x00\xD0\xC0\xDE\x00\xD0\xC0\xDE\xF0\x00\x00\x00\x00\x00\x00\x00': with open(dump, 'wb') as final: dolFile.save(final) if self.quiet: return if self.verbosity >= 3: dolFile.print_info() print('-'*64) if self.verbosity >= 1: print(tools.color_text('\n :: All codes have been successfully pre patched', defaultColor=tools.TGREENLIT)) return if self.patchJob == 'LEGACY': codeHandler.allocation = 0x80003000 - (codeHandler.initAddress + codeHandler.handlerLength) codeHandler.set_variables(dolFile) hooked = determine_codehook(dolFile, codeHandler, True) self.patch_legacy(codeHandler, dolFile) legacy = True else: hooked = determine_codehook(dolFile, codeHandler, False) self.patch_arena(codeHandler, dolFile) legacy = False if not hooked: self.error(tools.color_text('Failed to find a hook address. Try using option --codehook to use your own address\n', defaultColor=tools.TREDLIT)) elif codeHandler.allocation < codeHandler.geckoCodes.size: self.error(tools.color_text('\n :: Error: Allocated codespace was smaller than the given codelist.\n', defaultColor=tools.TYELLOW)) with open(dump, 'wb') as final: dolFile.save(final) if self.quiet: return if codeHandler.allocation > 0x70000: print(tools.color_text(f'\n :: WARNING: Allocations beyond 0x70000 will crash certain games. You allocated 0x{codeHandler.allocation:X}', defaultColor=tools.TYELLOW)) elif codeHandler.allocation > 0x40000: print(tools.color_text(f'\n :: HINT: Recommended allocation limit is 0x40000. You allocated 0x{codeHandler.allocation:X}', defaultColor=tools.TYELLOWLIT)) if self.verbosity >= 3: dolFile.print_info() print('-'*64) if self.verbosity >= 2: print('') if legacy == False: info = [f' :: Start of game modified to address 0x{self.initAddress:X}', f' :: Game function "__start()" located at address 0x{oldStart:X}', f' :: Allocation is 0x{codeHandler.allocation:X}; codelist size is 0x{codeHandler.geckoCodes.size:X}', f' :: Codehandler hooked at 0x{codeHandler.hookAddress:X}', f' :: Codehandler is of type "{codeHandler.type}"', f' :: Of the 7 text sections in this DOL file, {len(dolFile.textSections)} are now being used'] else: info = [f' :: Game function "__start()" located at address 0x{oldStart:X}', f' :: Allocation is 0x{codeHandler.allocation:X}; codelist size is 0x{codeHandler.geckoCodes.size:X}', f' :: Codehandler hooked at 0x{codeHandler.hookAddress:X}', f' :: Codehandler is of type "{codeHandler.type}"', f' :: Of the 7 text sections in this DOL file, {len(dolFile.textSections)} are now being used'] for bit in info: print(tools.color_text(bit, defaultColor=tools.TGREENLIT)) elif self.verbosity >= 1: print('') info = [f' :: GeckoLoader set at address 0x{self.initAddress:X}', f' :: Legacy size is 0x{codeHandler.allocation:X}; codelist size is 0x{codeHandler.geckoCodes.size:X}', f' :: Codehandler is of type "{codeHandler.type}"'] for bit in info: print(tools.color_text(bit, defaultColor=tools.TGREENLIT)) def resource_path(relative_path: str): """ Get absolute path to resource, works for dev and for PyInstaller """ base_path = getattr(sys, '_MEIPASS', os.path.dirname(os.path.abspath(__file__))) return os.path.join(base_path, relative_path) def determine_codehook(dolFile: DolFile, codeHandler: CodeHandler, hook=False): if codeHandler.hookAddress is None: if not assert_code_hook(dolFile, codeHandler): return False if hook: insert_code_hook(dolFile, codeHandler, codeHandler.hookAddress) return True def assert_code_hook(dolFile: DolFile, codeHandler: CodeHandler): for _, address, size, _, _ in dolFile.textSections: dolFile.seek(address) sample = dolFile.read(size) if codeHandler.hookType == 'VI': result = sample.find(codeHandler.gcnVIHook) elif codeHandler.hookType == 'GX': result = sample.find(codeHandler.gcnGXDrawHook) elif codeHandler.hookType == 'PAD': result = sample.find(codeHandler.gcnPADHook) else: raise NotImplementedError(tools.color_text(f'Unsupported hook type specified ({codeHandler.hookType})', defaultColor=tools.TREDLIT)) if result >= 0: dolFile.seek(address + result) else: if codeHandler.hookType == 'VI': result = sample.find(codeHandler.wiiVIHook) elif codeHandler.hookType == 'GX': result = sample.find(codeHandler.wiiGXDrawHook) elif codeHandler.hookType == 'PAD': result = sample.find(codeHandler.wiiPADHook) else: raise NotImplementedError(tools.color_text(f'Unsupported hook type specified ({codeHandler.hookType})', defaultColor=tools.TREDLIT)) if result >= 0: dolFile.seek(address + result) else: continue while (sample := read_uint32(dolFile)) != 0x4E800020: pass dolFile.seek(-4, 1) codeHandler.hookAddress = dolFile.tell() return True return False def insert_code_hook(dolFile: DolFile, codeHandler: CodeHandler, address: int): dolFile.seek(address) ppc = read_uint32(dolFile) if ((ppc >> 24) & 0xFF) > 0x3F and ((ppc >> 24) & 0xFF) < 0x48: raise NotImplementedError(tools.color_text('Hooking the codehandler to a conditional non spr branch is unsupported', defaultColor=tools.TREDLIT)) dolFile.seek(-4, 1) dolFile.insert_branch(codeHandler.startAddress, address, lk=0)