diff --git a/pokedex/extract/lib/gbz80.py b/pokedex/extract/lib/gbz80.py new file mode 100644 index 0000000..59b64b6 --- /dev/null +++ b/pokedex/extract/lib/gbz80.py @@ -0,0 +1,647 @@ +"""Stuff for dealing with the Game Boy's Z80-ish machine code. Most notably, +can do pattern-matching against a chunk of assembly with missing values. +""" +from collections import OrderedDict +from collections import defaultdict +import re + +import attr + +# TODO: would be nice to understand "cp a, #foo" and similar for xor/or/and/etc +# TODO: would be AMAZING to understand labels when searching for code wow + +# This table is courtesy of pokemon-reverse-engineering-tools: +# https://github.com/pret/pokemon-reverse-engineering-tools/blob/master/pokemontools/gbz80disasm.py +gbz80_bitops = dict(enumerate([ + "rlc b", "rlc c", "rlc d", "rlc e", "rlc h", "rlc l", "rlc [hl]", "rlc a", # $00 - $07 + "rrc b", "rrc c", "rrc d", "rrc e", "rrc h", "rrc l", "rrc [hl]", "rrc a", # $08 - $0f + "rl b", "rl c", "rl d", "rl e", "rl h", "rl l", "rl [hl]", "rl a", # $10 - $17 + "rr b", "rr c", "rr d", "rr e", "rr h", "rr l", "rr [hl]", "rr a", # $18 - $1f + "sla b", "sla c", "sla d", "sla e", "sla h", "sla l", "sla [hl]", "sla a", # $20 - $27 + "sra b", "sra c", "sra d", "sra e", "sra h", "sra l", "sra [hl]", "sra a", # $28 - $2f + "swap b", "swap c", "swap d", "swap e", "swap h", "swap l", "swap [hl]", "swap a", # $30 - $37 + "srl b", "srl c", "srl d", "srl e", "srl h", "srl l", "srl [hl]", "srl a", # $38 - $3f + "bit $00, b", "bit $00, c", "bit $00, d", "bit $00, e", "bit $00, h", "bit $00, l", "bit $00, [hl]", "bit $00, a", # $40 - $47 + "bit $01, b", "bit $01, c", "bit $01, d", "bit $01, e", "bit $01, h", "bit $01, l", "bit $01, [hl]", "bit $01, a", # $48 - $4f + "bit $02, b", "bit $02, c", "bit $02, d", "bit $02, e", "bit $02, h", "bit $02, l", "bit $02, [hl]", "bit $02, a", # $50 - $57 + "bit $03, b", "bit $03, c", "bit $03, d", "bit $03, e", "bit $03, h", "bit $03, l", "bit $03, [hl]", "bit $03, a", # $58 - $5f + "bit $04, b", "bit $04, c", "bit $04, d", "bit $04, e", "bit $04, h", "bit $04, l", "bit $04, [hl]", "bit $04, a", # $60 - $67 + "bit $05, b", "bit $05, c", "bit $05, d", "bit $05, e", "bit $05, h", "bit $05, l", "bit $05, [hl]", "bit $05, a", # $68 - $6f + "bit $06, b", "bit $06, c", "bit $06, d", "bit $06, e", "bit $06, h", "bit $06, l", "bit $06, [hl]", "bit $06, a", # $70 - $77 + "bit $07, b", "bit $07, c", "bit $07, d", "bit $07, e", "bit $07, h", "bit $07, l", "bit $07, [hl]", "bit $07, a", # $78 - $7f + "res $00, b", "res $00, c", "res $00, d", "res $00, e", "res $00, h", "res $00, l", "res $00, [hl]", "res $00, a", # $80 - $87 + "res $01, b", "res $01, c", "res $01, d", "res $01, e", "res $01, h", "res $01, l", "res $01, [hl]", "res $01, a", # $88 - $8f + "res $02, b", "res $02, c", "res $02, d", "res $02, e", "res $02, h", "res $02, l", "res $02, [hl]", "res $02, a", # $90 - $97 + "res $03, b", "res $03, c", "res $03, d", "res $03, e", "res $03, h", "res $03, l", "res $03, [hl]", "res $03, a", # $98 - $9f + "res $04, b", "res $04, c", "res $04, d", "res $04, e", "res $04, h", "res $04, l", "res $04, [hl]", "res $04, a", # $a0 - $a7 + "res $05, b", "res $05, c", "res $05, d", "res $05, e", "res $05, h", "res $05, l", "res $05, [hl]", "res $05, a", # $a8 - $af + "res $06, b", "res $06, c", "res $06, d", "res $06, e", "res $06, h", "res $06, l", "res $06, [hl]", "res $06, a", # $b0 - $b7 + "res $07, b", "res $07, c", "res $07, d", "res $07, e", "res $07, h", "res $07, l", "res $07, [hl]", "res $07, a", # $b8 - $bf + "set $00, b", "set $00, c", "set $00, d", "set $00, e", "set $00, h", "set $00, l", "set $00, [hl]", "set $00, a", # $c0 - $c7 + "set $01, b", "set $01, c", "set $01, d", "set $01, e", "set $01, h", "set $01, l", "set $01, [hl]", "set $01, a", # $c8 - $cf + "set $02, b", "set $02, c", "set $02, d", "set $02, e", "set $02, h", "set $02, l", "set $02, [hl]", "set $02, a", # $d0 - $d7 + "set $03, b", "set $03, c", "set $03, d", "set $03, e", "set $03, h", "set $03, l", "set $03, [hl]", "set $03, a", # $d8 - $df + "set $04, b", "set $04, c", "set $04, d", "set $04, e", "set $04, h", "set $04, l", "set $04, [hl]", "set $04, a", # $e0 - $e7 + "set $05, b", "set $05, c", "set $05, d", "set $05, e", "set $05, h", "set $05, l", "set $05, [hl]", "set $05, a", # $e8 - $ef + "set $06, b", "set $06, c", "set $06, d", "set $06, e", "set $06, h", "set $06, l", "set $06, [hl]", "set $06, a", # $f0 - $f7 + "set $07, b", "set $07, c", "set $07, d", "set $07, e", "set $07, h", "set $07, l", "set $07, [hl]", "set $07, a" # $f8 - $ff +])) + +# This instruction list was carefully scraped from: +# http://www.pastraiser.com/cpu/gameboy/gameboy_opcodes.html +gbz80_instructions = { + 0x00: 'nop', + 0x01: 'ld bc, #d16', + 0x02: 'ld [bc], a', + 0x03: 'inc bc', + 0x04: 'inc b', + 0x05: 'dec b', + 0x06: 'ld b, #d8', + 0x07: 'rlca', + 0x08: 'ld [#a16], sp', + 0x09: 'add hl, bc', + 0x0a: 'ld a, [bc]', + 0x0b: 'dec bc', + 0x0c: 'inc c', + 0x0d: 'dec c', + 0x0e: 'ld c, #d8', + 0x0f: 'rrca', + + 0x10: 'stop', + 0x11: 'ld de, #d16', + 0x12: 'ld [de], a', + 0x13: 'inc de', + 0x14: 'inc d', + 0x15: 'dec d', + 0x16: 'ld d, #d8', + 0x17: 'rla', + 0x18: 'jr #r8', + 0x19: 'add hl, de', + 0x1a: 'ld a, [de]', + 0x1b: 'dec de', + 0x1c: 'inc e', + 0x1d: 'dec e', + 0x1e: 'ld e, #d8', + 0x1f: 'rra', + + 0x20: 'jr nz, #r8', + 0x21: 'ld hl, #d16', + 0x22: 'ld [hl+], a', + 0x23: 'inc hl', + 0x24: 'inc h', + 0x25: 'dec h', + 0x26: 'ld h, #d8', + 0x27: 'daa', + 0x28: 'jr z, #r8', + 0x29: 'add hl, hl', + 0x2a: 'ld a, [hl+]', + 0x2b: 'dec hl', + 0x2c: 'inc l', + 0x2d: 'dec l', + 0x2e: 'ld l, #d8', + 0x2f: 'cpl', + + 0x30: 'jr nc, #r8', + 0x31: 'ld sp, #d16', + 0x32: 'ld [hl-], a', + 0x33: 'inc sp', + 0x34: 'inc [hl]', + 0x35: 'dec [hl]', + 0x36: 'ld [hl], #d8', + 0x37: 'scf', + 0x38: 'jr c, #r8', + 0x39: 'add hl, sp', + 0x3a: 'ld a, [hl-]', + 0x3b: 'dec sp', + 0x3c: 'inc a', + 0x3d: 'dec a', + 0x3e: 'ld a, #d8', + 0x3f: 'ccf', + + 0x40: 'ld b, b', + 0x41: 'ld b, c', + 0x42: 'ld b, d', + 0x43: 'ld b, e', + 0x44: 'ld b, h', + 0x45: 'ld b, l', + 0x46: 'ld b, [hl]', + 0x47: 'ld b, a', + 0x48: 'ld c, b', + 0x49: 'ld c, c', + 0x4a: 'ld c, d', + 0x4b: 'ld c, e', + 0x4c: 'ld c, h', + 0x4d: 'ld c, l', + 0x4e: 'ld c, [hl]', + 0x4f: 'ld c, a', + + 0x50: 'ld d, b', + 0x51: 'ld d, c', + 0x52: 'ld d, d', + 0x53: 'ld d, e', + 0x54: 'ld d, h', + 0x55: 'ld d, l', + 0x56: 'ld d, [hl]', + 0x57: 'ld d, a', + 0x58: 'ld e, b', + 0x59: 'ld e, c', + 0x5a: 'ld e, d', + 0x5b: 'ld e, e', + 0x5c: 'ld e, h', + 0x5d: 'ld e, l', + 0x5e: 'ld e, [hl]', + 0x5f: 'ld e, a', + + 0x60: 'ld h, b', + 0x61: 'ld h, c', + 0x62: 'ld h, d', + 0x63: 'ld h, e', + 0x64: 'ld h, h', + 0x65: 'ld h, l', + 0x66: 'ld h, [hl]', + 0x67: 'ld h, a', + 0x68: 'ld l, b', + 0x69: 'ld l, c', + 0x6a: 'ld l, d', + 0x6b: 'ld l, e', + 0x6c: 'ld l, h', + 0x6d: 'ld l, l', + 0x6e: 'ld l, [hl]', + 0x6f: 'ld l, a', + + 0x70: 'ld [hl], b', + 0x71: 'ld [hl], c', + 0x72: 'ld [hl], d', + 0x73: 'ld [hl], e', + 0x74: 'ld [hl], h', + 0x75: 'ld [hl], l', + 0x76: 'halt', + 0x77: 'ld [hl], a', + 0x78: 'ld a, b', + 0x79: 'ld a, c', + 0x7a: 'ld a, d', + 0x7b: 'ld a, e', + 0x7c: 'ld a, h', + 0x7d: 'ld a, l', + 0x7e: 'ld a, [hl]', + 0x7f: 'ld a, a', + + 0x80: 'add a, b', + 0x81: 'add a, c', + 0x82: 'add a, d', + 0x83: 'add a, e', + 0x84: 'add a, h', + 0x85: 'add a, l', + 0x86: 'add a, [hl]', + 0x87: 'add a, a', + 0x88: 'adc a, b', + 0x89: 'adc a, c', + 0x8a: 'adc a, d', + 0x8b: 'adc a, e', + 0x8c: 'adc a, h', + 0x8d: 'adc a, l', + 0x8e: 'adc a, [hl]', + 0x8f: 'adc a, a', + + 0x90: 'sub b', + 0x91: 'sub c', + 0x92: 'sub d', + 0x93: 'sub e', + 0x94: 'sub h', + 0x95: 'sub l', + 0x96: 'sub [hl]', + 0x97: 'sub a', + 0x98: 'sbc a, b', + 0x99: 'sbc a, c', + 0x9a: 'sbc a, d', + 0x9b: 'sbc a, e', + 0x9c: 'sbc a, h', + 0x9d: 'sbc a, l', + 0x9e: 'sbc a, [hl]', + 0x9f: 'sbc a, a', + + 0xa0: 'and b', + 0xa1: 'and c', + 0xa2: 'and d', + 0xa3: 'and e', + 0xa4: 'and h', + 0xa5: 'and l', + 0xa6: 'and [hl]', + 0xa7: 'and a', + 0xa8: 'xor b', + 0xa9: 'xor c', + 0xaa: 'xor d', + 0xab: 'xor e', + 0xac: 'xor h', + 0xad: 'xor l', + 0xae: 'xor [hl]', + 0xaf: 'xor a', + + 0xb0: 'or b', + 0xb1: 'or c', + 0xb2: 'or d', + 0xb3: 'or e', + 0xb4: 'or h', + 0xb5: 'or l', + 0xb6: 'or [hl]', + 0xb7: 'or a', + 0xb8: 'cp b', + 0xb9: 'cp c', + 0xba: 'cp d', + 0xbb: 'cp e', + 0xbc: 'cp h', + 0xbd: 'cp l', + 0xbe: 'cp [hl]', + 0xbf: 'cp a', + + 0xc0: 'ret nz', + 0xc1: 'pop bc', + 0xc2: 'jp nz, #a16', + 0xc3: 'jp #a16', + 0xc4: 'call nz, #a16', + 0xc5: 'push bc', + 0xc6: 'add a, #d8', + 0xc7: 'rst $00', + 0xc8: 'ret z', + 0xc9: 'ret', + 0xca: 'jp z, #a16', + 0xcb: gbz80_bitops, + 0xcc: 'call z, #a16', + 0xcd: 'call #a16', + 0xce: 'adc a, #d8', + 0xcf: 'rst $08', + + 0xd0: 'ret nc', + 0xd1: 'pop de', + 0xd2: 'jp nc, #a16', + # 0xd3 + 0xd4: 'call nc, #a16', + 0xd5: 'push de', + 0xd6: 'sub #d8', + 0xd7: 'rst $10', + 0xd8: 'ret c', + 0xd9: 'reti', + 0xda: 'jp c, #a16', + # 0xdb + 0xdc: 'call c, #a16', + # 0xdd + 0xde: 'sbc a, #d8', + 0xdf: 'rst $18', + + 0xe0: 'ldh [#a8], a', + 0xe1: 'pop hl', + 0xe2: 'ld [$ff00+c], a', # XXX table claims 2 but this looks like 1 to me + # 0xe3 + # 0xe4 + 0xe5: 'push hl', + 0xe6: 'and #d8', + 0xe7: 'rst $20', + 0xe8: 'add sp, #r8', + 0xe9: 'jp [hl]', + 0xea: 'ld [#a16], a', + # 0xeb + # 0xec + # 0xed + 0xee: 'xor #d8', + 0xef: 'rst $28', + + 0xf0: 'ldh a, [#a8]', + 0xf1: 'pop af', + 0xf2: 'ld a, [$ff00+c]', # XXX table says 1 but this looks like 1 to me + 0xf3: 'di', + # 0xf4 + 0xf5: 'push af', + 0xf6: 'or #d8', + 0xf7: 'rst $30', + 0xf8: 'ld hl, sp+#r8', + 0xf9: 'ld sp, hl', + 0xfa: 'ld a, [#a16]', + 0xfb: 'ei', + # 0xfc + # 0xfd + 0xfe: 'cp #d8', + 0xff: 'rst $38', +} + + +class Atom: + is_constant = False + is_input = False + is_register = False + + def is_compatible_with(self, other): + return self == other + + def render(self): + raise NotImplementedError + + +@attr.s +class InputAtom(Atom): + name = attr.ib() + length = attr.ib() + is_input = True + + def is_compatible_with(self, other): + # Inputs are compatible with anything that's not a register + # TODO does length matter? + return isinstance(other, (InputAtom, ConstantAtom)) + + def render(self, value=None): + if value is None: + return '#' + self.name + else: + return "${:0{width}x}".format(value, width=self.length * 2) + + +@attr.s +class RegisterAtom(Atom): + name = attr.ib() + is_register = True + + def render(self): + return self.name + + +@attr.s +class ConstantAtom(Atom): + value = attr.ib() + is_constant = True + + def render(self): + if self.value < 256: + return "${:02x}".format(self.value) + else: + return "${:04x}".format(self.value) + + +class Instruction: + def __init__(self, syntax, prefix, mnemonic, length, args, inputs): + self.syntax = syntax + self.prefix = prefix + self.mnemonic = mnemonic + self.length = length + # list of (items_to_sum, is_pointer) tuples + self.args = args + self.inputs = inputs + + @staticmethod + def partial_parse(syntax): + mnemonic, *argstrs = re.split('[, ]+', syntax) + args = [] + + for argstr in argstrs: + ptr = False + if argstr.startswith('[') and argstr.endswith(']'): + ptr = True + argstr = argstr[1:-1] + + atoms = [] + for atomstr in re.split('[+](?=.)', argstr): + if atomstr.startswith('#'): + atom = InputAtom(atomstr[1:], None) + elif atomstr in ( + 'a', 'f', 'b', 'c', 'd', 'e', 'h', 'l', + 'af', 'bc', 'de', 'hl', 'hl+', 'hl-', + 'sp', 'pc', 'z', 'nz', 'c', 'nc', + ): + atom = RegisterAtom(atomstr) + elif atomstr.startswith('$'): + atom = ConstantAtom(int(atomstr[1:], 16)) + elif atomstr.isdigit(): + atom = ConstantAtom(int(atomstr)) + else: + raise SyntaxError( + "Unrecognized argument {!r} in instruction {!r}" + .format(atomstr, syntax)) + + atoms.append(atom) + + args.append((atoms, ptr)) + + return mnemonic, args + + @classmethod + def parse(cls, syntax, prefix): + mnemonic, args = cls.partial_parse(syntax) + inputs = [] + + length = len(prefix) + for atoms, is_ptr in args: + for atom in atoms: + if not atom.is_input: + continue + if atom.name in ('d16', 'a16'): + atom.length = 2 + elif atom.name in ('d8', 'a8', 'r8'): + atom.length = 1 + else: + raise SyntaxError( + "Unrecognized input name {}".format(atom.name)) + + inputs.append(atom) + length += atom.length + + self = cls(syntax, prefix, mnemonic, length, args, inputs) + assert self(ignore_inputs=True) == syntax + return self + + def __repr__(self): + return "<{} 0x{}: {}>".format( + type(self).__name__, + self.prefix.hex(), + self(ignore_inputs=True), + ) + + def __call__(self, *inputs, ignore_inputs=False): + inputs = list(inputs) + if not ignore_inputs: + if len(inputs) != len(self.inputs): + raise TypeError( + "{} needs {} inputs, got {}" + .format(self.syntax, len(self.inputs), len(inputs))) + + args = [] + for atoms, is_ptr in self.args: + atomstrs = [] + for atom in atoms: + if not ignore_inputs and atom.is_input: + atomstrs.append(atom.render(inputs.pop(0))) + else: + atomstrs.append(atom.render()) + expr = '+'.join(atomstrs) + if is_ptr: + expr = '[' + expr + ']' + args.append(expr) + + out = self.mnemonic + if args: + out = out + ' ' + ', '.join(args) + return out + + def match_inputs(self, mnemonic, args): + if self.mnemonic != mnemonic: + return + if len(self.args) != len(args): + return + + # Compare args + input_pairs = [] + for (atoms1, ptr1), (atoms2, ptr2) in zip(self.args, args): + if ptr1 != ptr2: + return + if len(atoms1) != len(atoms2): + return + # TODO technically, A+B is the same as B+A, but the lists are het + # so i can't sort + # TODO also, constant folding could make A+B the same as C + for atom1, atom2 in zip(atoms1, atoms2): + if not atom1.is_compatible_with(atom2): + return + if atom1.is_input: + input_pairs.append((atom1, atom2)) + + return input_pairs + + +class InstructionSet: + def __init__(self, instructions): + self.instructions = {} + self.mnemonics = defaultdict(set) + self._load_instructions(instructions) + + def _load_instructions(self, instructions, *, prefix=b''): + for n, syntax in instructions.items(): + byte = bytes([n]) + if isinstance(syntax, dict): + # Nested args, for the bitops instruction + self._load_instructions(syntax, prefix=byte) + else: + instr = Instruction.parse(syntax, prefix + byte) + self.instructions[prefix + byte] = instr + self.mnemonics[instr.mnemonic].add(instr) + + +gbz80 = InstructionSet(gbz80_instructions) + +needle = """push bc +push hl +ld a, [#wd11e] +dec a +ld hl, #PokedexOrder +ld b, 0 +ld c, a +add hl, bc +ld a, [hl] +ld [#wd11e], a +pop hl +pop bc +ret""" +""" + \xc5 + \xe5 + \xfa (..) + \x3d + \x21 (..) + \x06 \x00 + \x4f + \x09 + \x7e + \xea \1 + \xe1 + \xc1 + \xc9 + """ +haystack = b'\xc5\xe5\xfaXY\x3d\x21ZW\x06\x00\x4f\x09\x7e\xeaXY\xe1\xc1\xc9' + +# ------------------------------------------------------------------------------ +# Disassemble + +def disassemble(haystack): + i = 0 + while i < len(haystack): + for l in range(2): + prefix = haystack[i:i+l+1] + if prefix in gbz80.instructions: + instr = gbz80.instructions[prefix] + break + else: + raise SyntaxError + + i += len(prefix) + inputs = [] + for inp in instr.inputs: + inputs.append(int.from_bytes( + haystack[i:i + inp.length], byteorder='little')) + i += inp.length + + print(instr(*inputs)) + + +# ------------------------------------------------------------------------------ +# Pattern match + +def find_code(haystack, needle, **kwargs): + # TODO error if something in kwargs isn't a pattern input? + # TODO the return value here is goofy + # TODO maybe use finditer and yield instead + pattern_chunks = [] + input_table = OrderedDict() + matched_instructions = [] + for instruction in needle.splitlines(): + instruction = re.sub(';.*', '', instruction).strip() + if not instruction: + continue + mnemonic, args = Instruction.partial_parse(instruction) + candidates = gbz80.mnemonics[mnemonic] + for candidate in candidates: + inputs = candidate.match_inputs(mnemonic, args) + if inputs is not None: + break + else: + raise SyntaxError + + instr = candidate + pattern_chunks.append(re.escape(instr.prefix)) + pattern_atoms = [] + for instr_input, pattern_atom in inputs: + pattern_atoms.append(pattern_atom) + if pattern_atom.is_constant: + pattern_chunks.append(re.escape( + pattern_atom.value.to_bytes( + instr_input.length, byteorder='little'))) + elif pattern_atom.name in input_table: + pattern_chunks.append(input_table[pattern_atom.name]) + else: + if pattern_atom.name in kwargs: + inner_pattern = re.escape( + kwargs[pattern_atom.name].to_bytes( + instr_input.length, byteorder='little')) + else: + inner_pattern = b'.' * instr_input.length + + group_name = pattern_atom.name.encode('ascii') + input_table[pattern_atom.name] = b'(?P=%b)' % (group_name,) + pattern_chunks.append(b'(?P<%b>%b)' % (group_name, inner_pattern)) + matched_instructions.append((instr, pattern_atoms)) + + pattern = b''.join(pattern_chunks) + + m = re.search(pattern, haystack, flags=re.DOTALL) + if m: + matched_inputs = {} + for inp in input_table: + matched_inputs[inp] = int.from_bytes( + m.group(inp), byteorder='little') + + for instr, pattern_atoms in matched_instructions: + inputs = [] + for atom in pattern_atoms: + if atom.is_constant: + inputs.append(atom.value) + else: + inputs.append(matched_inputs[atom.name]) + + return m, matched_inputs + else: + return diff --git a/pokedex/extract/rby.py b/pokedex/extract/rby.py index a4fd160..219be0e 100644 --- a/pokedex/extract/rby.py +++ b/pokedex/extract/rby.py @@ -14,13 +14,13 @@ import hashlib import io import logging from pathlib import Path -import re import sys from camel import Camel from classtools import reify from construct import * +from pokedex.extract.lib.gbz80 import find_code import pokedex.schema as schema # TODO set this up to colorcode and use {} formatting @@ -1167,8 +1167,6 @@ pokemon_struct = Struct( Padding(1), ) -pokemon_name_struct = PokemonCString('pokemon_name', 10) - evos_moves_struct = Struct( 'evos_moves', @@ -1281,28 +1279,17 @@ class RBYCart: Return a dict of raw file offsets. The keys are the names used in the pokered project. """ - # The base stats are always in the same place in RBY, and only slightly - # off in RG. Not sure why! But it hopefully means recompilation - # doesn't affect them. - addresses = { - # These ones have, thusfar, defied automatic detection, as they're - # just part of a big old block of data — so I can't just look for - # code nearby. - # TODO these are for rby; fix for rg, and maybe y? - 'BaseStats': unbank('0E:43DE'), - 'MewBaseStats': unbank('01:425B'), - } - - # For everything else, the general approach is to find some assembly - # code that appears just before the data of interest. It's pretty - # hacky, but since translators (and even modders) would have little - # reason to rearrange functions or inject new ones in these odd places, - # it ought to work well enough. And it's better than ferreting out and - # hard-coding piles of addresses. + # The ideal approach is to find some assembly code that appears just + # before the data of interest. It's pretty hacky, but since + # translators (and even modders) would have little reason to rearrange + # functions or inject new ones in these odd places, it ought to work + # well enough. And it's better than ferreting out and hard-coding + # piles of addresses. # The only hard part is that assembly code that contains an address # won't work, since that address will also vary per game. # Each of the landmarks used here appears in every official cartridge # exactly once. + addresses = {} # This is an entire function used by the Pokédex and which immediately # precedes all the flavor text. @@ -1322,6 +1309,72 @@ class RBYCart: raise CartDetectionError("Can't find evolution and moveset table") addresses['EvosMovesPointerTable'] = idx + len(asm_WriteMonMoves_ShiftMoveData) + 5 + # Several lists of names are accessed by a single function, which looks + # through a list of pointers to find the right set of names to use. + # That's great news for me: I can just grab all of those delicious + # pointers at once. Here's an excerpt from GetName. + match = find_code(self.data, ''' + inc d + ;.skip + ld hl, #NamePointers + add hl,de + ld a,[hl+] + ldh [$96],a + ld a,[hl] + ldh [$95],a + ldh a,[$95] + ld h,a + ldh a,[$96] + ld l,a + ld a,[#wd0b5] + ld b,a + ld c,0 + ;.nextName + ld d,h + ld e,l + ;.nextChar + ld a,[hl+] + cp $50 ; terminator @, encoded + ''') + if not match: + raise CartDetectionError("Can't find name array") + rem, inputs = match + start = inputs['NamePointers'] + name_pointers = Array(7, ULInt16('dummy')).parse( + self.data[start:start + 14]) + # One downside to the Game Boy memory structure is that banks are + # not stored anywhere near their corresponding addresses. Most + # bank numbers are hardcoded here, but Pokémon names are in a different + # bank in Japanese games, so we've gotta scrape the bank too... + match = find_code(self.data, ''' + ;GetMonName:: + push hl + ldh a,[#H_LOADEDROMBANK] + push af + ld a,#BANK_MonsterNames + ldh [#H_LOADEDROMBANK],a + ld [#MBC1RomBank],a + ld a,[#wd11e] + dec a + ld hl,#MonsterNames + ''', + H_LOADEDROMBANK=0xB8, # full address is $FFB8; ldh adds the $FF + MBC1RomBank=0x2000, + MonsterNames=name_pointers[0] + ) + if not match: + raise CartDetectionError("Can't find Pokémon names") + rem, inputs = match + + addresses['MonsterNames'] = unbank( + inputs['BANK_MonsterNames'], name_pointers[0]) + addresses['MoveNames'] = unbank(0x2C, name_pointers[1]) + # 2: UnusedNames (unused, obviously) + addresses['ItemNames'] = unbank(0x01, name_pointers[3]) + # 4: wPartyMonOT (only useful while the game is running) + # 5: wEnemyMonOT (only useful while the game is running) + addresses['TrainerNames'] = unbank(0x0E, name_pointers[6]) + # Finding TMs is a bit harder. They come right after a function for # looking up a TM number, which is very short and very full of # addresses. So here's a regex. @@ -1330,26 +1383,29 @@ class RBYCart: # In English it is, unsurprisingly, 0xD11E. # `TechnicalMachines` is the address we're looking for, which should # immediately follow what this matches. - asm_TMToMove_rx = re.compile(rb''' - \xfa (..) # ld a, [wd11e] - \x3d # dec a - \x21 (..) # ld hl, TechnicalMachines - \x06 \x00 # ld b, $0 - \x4f # ld c, a - \x09 # add hl, bc - \x7e # ld a, [hl] - \xea \1 # ld [wd11e], a - \xc9 # ret - ''', flags=re.DOTALL | re.VERBOSE) - for match in asm_TMToMove_rx.finditer(self.data): - matched_addr = ULInt16('...').parse(match.group(2)) - tentative_addr = match.end() + match = find_code(self.data, ''' + ld a, [#wd11e] + dec a + ld hl, #TechnicalMachines + ld b, $0 + ld c, a + add hl, bc + ld a, [hl] + ld [#wd11e], a + ret + ''') + if match: + rem, inputs = match + # TODO this should mayybe also check that the address immediately follows this code + matched_addr = inputs['TechnicalMachines'] + tentative_addr = rem.end() # Remember, addresses don't include the bank! _, banked_addr = bank(tentative_addr) if matched_addr == banked_addr: - asm_wd11e_addr = match.group(1) + asm_wd11e_addr = inputs['wd11e'] addresses['TechnicalMachines'] = tentative_addr - break + else: + raise RuntimeError # TODO should there really be more than one match? else: raise CartDetectionError("Can't find technical machines list") @@ -1359,61 +1415,107 @@ class RBYCart: # These are almost immediately after the Pokédex entries themselves, # but this actually seems easier than figuring out where a table of # pointers ends. - asm_IndexToPokedex_rx = re.compile(rb''' - \xc5 # push bc - \xe5 # push hl - \xfa (..) # ld a,[wd11e] - \x3d # dec a - \x21 (..) # ld hl,PokedexOrder - \x06 \x00 # ld b,0 - \x4f # ld c,a - \x09 # add hl,bc - \x7e # ld a,[hl] - \xea \1 # ld [wd11e],a - \xe1 # pop hl - \xc1 # pop bc - \xc9 # ret - ''', flags=re.DOTALL | re.VERBOSE) - for match in asm_IndexToPokedex_rx.finditer(self.data): - matched_addr = ULInt16('...').parse(match.group(2)) - tentative_addr = match.end() + match = find_code(self.data, ''' + push bc + push hl + ld a, [#wd11e] + dec a + ld hl, #PokedexOrder + ld b, 0 + ld c, a + add hl, bc + ld a, [hl] + ld [#wd11e], a + pop hl + pop bc + ret + ''', wd11e=asm_wd11e_addr) + if match: + rem, inputs = match + matched_addr = inputs['PokedexOrder'] + tentative_addr = rem.end() # Remember, addresses don't include the bank! _, banked_addr = bank(tentative_addr) - if matched_addr == banked_addr and asm_wd11e_addr == match.group(1): + if matched_addr == banked_addr: addresses['PokedexOrder'] = tentative_addr - break + else: + raise RuntimeError else: raise CartDetectionError("Can't find Pokédex order") - # This is assembly code that appears near the end of a function called - # WaitForSoundToFinish. - end_of_WaitForSoundToFinish = bytes.fromhex('afb6 23b6 2323 b6') - try: - idx = self.data.index(end_of_WaitForSoundToFinish) - except ValueError: - raise CartDetectionError("Can't find name array") - # There are a couple more bytes in the function, but they involve an - # address so they can't be searched for. Red/Green/Blue have four; - # Yellow has an extra 'and', which is annoying, but at least easy to - # handle. - start = idx + len(end_of_WaitForSoundToFinish) - if self.data[start] == 0xA7: - # Yellow; skip one more byte - start += 1 - start += 4 - - name_pointers = Array(7, ULInt16('dummy')).parse(self.data[start:start + 14]) - # One downside to the Game Boy memory structure is that banks are not - # stored anywhere near their corresponding addresses, so the bank - # numbers are hardcoded here. They're fairly unlikely to change - # between games. Right? Probably? - addresses['MonsterNames'] = unbank(0x07, name_pointers[0]) - addresses['MoveNames'] = unbank(0x2C, name_pointers[1]) - # 2: UnusedNames (unused, obviously) - addresses['ItemNames'] = unbank(0x01, name_pointers[3]) - # 4: wPartyMonOT (only useful while the game is running) - # 5: wEnemyMonOT (only useful while the game is running) - addresses['TrainerNames'] = unbank(0x0E, name_pointers[6]) + # Ah, but then, we have base stats. These don't have code nearby; + # they're just stuck immediately after moves. Except in R/G, where + # they appear /before/ moves! And we don't know what version we're + # running yet, because the addresses detected in this method are used + # for language detection. Hmm. + # Here's plan B: look for the function that /loads/ base stats, and + # scrape the address out of it. This function is a bit hairy; I've had + # to expand some of pokered's macros and rewrite the jumps to something + # that the rudimentary code matcher can understand. + match = find_code(self.data, ''' + ldh a, [#H_LOADEDROMBANK] + push af + ld a, #BANK_BaseStats + ldh [#H_LOADEDROMBANK], a + ld [#MBC1RomBank], a + push bc + push de + push hl + ld a, [#wd11e] + push af + ld a,[#wd0b5] + ld [#wd11e],a + ld de,#FossilKabutopsPic + ld b,$66 ; size of Kabutops fossil and Ghost sprites + cp #FOSSIL_KABUTOPS ; Kabutops fossil + jr z,#specialID1 + ld de,#GhostPic + cp #MON_GHOST ; Ghost + jr z,#specialID2 + ld de,#FossilAerodactylPic + ld b,$77 ; size of Aerodactyl fossil sprite + cp #FOSSIL_AERODACTYL ; Aerodactyl fossil + jr z,#specialID3 + cp #MEW + jr z,#mew + ld a, #IndexToPokedexPredef + call #IndexToPokedex ; convert pokemon ID in [wd11e] to pokedex number + ld a,[#wd11e] + dec a + ld bc, #MonBaseStatsLength + ld hl, #BaseStats + call #AddNTimes + ld de, #wMonHeader + ld bc, #MonBaseStatsLength + call #CopyData + jr #done1 + ;.specialID + ld hl, #wMonHSpriteDim + ld [hl], b ; write sprite dimensions + inc hl + ld [hl], e ; write front sprite pointer + inc hl + ld [hl], d + jr #done2 + ;.mew + ld hl, #MewBaseStats + ld de, #wMonHeader + ld bc, #MonBaseStatsLength + ld a, #BANK_MewBaseStats + call #FarCopyData + ''', + # These are constants; I left them in the above code for clarity + H_LOADEDROMBANK=0xB8, # full address is $FFB8; ldh adds the $FF + MBC1RomBank=0x2000, + # This was scraped previously + wd11e=asm_wd11e_addr, + ) + if match: + rem, inputs = match + addresses['BaseStats'] = unbank(inputs['BANK_BaseStats'], inputs['BaseStats']) + addresses['MewBaseStats'] = unbank(inputs['BANK_MewBaseStats'], inputs['MewBaseStats']) + else: + raise CartDetectionError("Can't find base stats") return addresses @@ -1612,7 +1714,12 @@ class RBYCart: ret = [None] * self.NUM_POKEMON self.stream.seek(self.addrs['MonsterNames']) - for index, pokemon_name in enumerate(Array(self.max_pokemon_index, pokemon_name_struct).parse_stream(self.stream), start=1): + # TODO i don't like this, but they don't have explicit terminators... + if self.language == 'ja': + name_length = 5 + else: + name_length = 10 + for index, pokemon_name in enumerate(Array(self.max_pokemon_index, PokemonCString('...', name_length)).parse_stream(self.stream), start=1): try: id = self.pokedex_order[index] except KeyError: @@ -1631,7 +1738,6 @@ class RBYCart: def pokemon_records(self): """List of pokemon_structs.""" self.stream.seek(self.addrs['BaseStats']) - print(self.stream.read(100).hex()) records = Array(self.NUM_POKEMON - 1, pokemon_struct).parse_stream(self.stream) # Mew's data is, awkwardly, stored separately self.stream.seek(self.addrs['MewBaseStats'])