From 1513496f6091dd9ef127def8464a22991d0602e9 Mon Sep 17 00:00:00 2001 From: testyourmine <25854988+testyourmine@users.noreply.github.com> Date: Mon, 8 Jan 2024 16:05:30 -0600 Subject: [PATCH] Added Port_Extraction folder and edited readme. --- .../bank_80/extract_area_elevator_bits.py | 5 + Port_Extraction/bank_80/extract_bank_80.py | 23 + Port_Extraction/bank_81/extract_bank_81.py | 492 ++++++++ Port_Extraction/bank_82/extract_bank_82.py | 1057 +++++++++++++++++ Port_Extraction/bank_84/extract_bank_84.py | 384 ++++++ Port_Extraction/bank_85/extract_bank_85.py | 68 ++ Port_Extraction/bank_86/extract_bank_86.py | 75 ++ Port_Extraction/bank_88/extract_bank_88.py | 42 + Port_Extraction/bank_89/extract_bank_89.py | 27 + Port_Extraction/bank_8B/extract_bank_8B.py | 70 ++ Port_Extraction/bank_90/extract_bank_90.py | 31 + Port_Extraction/bank_91/extract_bank_91.py | 59 + .../bank_91/extract_samus_pose_transitions.py | 172 +++ Port_Extraction/bank_91/poses.txt | 253 ++++ Port_Extraction/bank_92/extract_bank_92.py | 21 + Port_Extraction/bank_93/extract_bank_93.py | 35 + Port_Extraction/bank_94/extract_bank_94.py | 25 + Port_Extraction/bank_9B/extract_bank_9B.py | 81 ++ Port_Extraction/bank_A0/extract_bank_A0.py | 29 + Port_Extraction/bank_A2/extract_bank_A2.py | 82 ++ Port_Extraction/bank_A3/extract_bank_A3.py | 119 ++ Port_Extraction/bank_A4/extract_bank_A4.py | 51 + Port_Extraction/bank_A5/extract_bank_A5.py | 47 + Port_Extraction/bank_A6/extract_bank_A6.py | 121 ++ Port_Extraction/bank_A7/extract_bank_A7.py | 87 ++ Port_Extraction/bank_A8/extract_bank_A8.py | 69 ++ Port_Extraction/bank_A9/extract_bank_A9.py | 65 + Port_Extraction/bank_AA/extract_bank_AA.py | 61 + Port_Extraction/bank_AD/extract_bank_AD.py | 31 + Port_Extraction/bank_B2/extract_bank_B2.py | 19 + Port_Extraction/bank_B3/extract_bank_B3.py | 43 + Port_Extraction/bank_B4/extract_bank_B4.py | 18 + Port_Extraction/common_data.py | 389 ++++++ Port_Extraction/out_92_original.txt | Bin 0 -> 316804 bytes README.md | 15 +- 35 files changed, 4162 insertions(+), 4 deletions(-) create mode 100644 Port_Extraction/bank_80/extract_area_elevator_bits.py create mode 100644 Port_Extraction/bank_80/extract_bank_80.py create mode 100644 Port_Extraction/bank_81/extract_bank_81.py create mode 100644 Port_Extraction/bank_82/extract_bank_82.py create mode 100644 Port_Extraction/bank_84/extract_bank_84.py create mode 100644 Port_Extraction/bank_85/extract_bank_85.py create mode 100644 Port_Extraction/bank_86/extract_bank_86.py create mode 100644 Port_Extraction/bank_88/extract_bank_88.py create mode 100644 Port_Extraction/bank_89/extract_bank_89.py create mode 100644 Port_Extraction/bank_8B/extract_bank_8B.py create mode 100644 Port_Extraction/bank_90/extract_bank_90.py create mode 100644 Port_Extraction/bank_91/extract_bank_91.py create mode 100644 Port_Extraction/bank_91/extract_samus_pose_transitions.py create mode 100644 Port_Extraction/bank_91/poses.txt create mode 100644 Port_Extraction/bank_92/extract_bank_92.py create mode 100644 Port_Extraction/bank_93/extract_bank_93.py create mode 100644 Port_Extraction/bank_94/extract_bank_94.py create mode 100644 Port_Extraction/bank_9B/extract_bank_9B.py create mode 100644 Port_Extraction/bank_A0/extract_bank_A0.py create mode 100644 Port_Extraction/bank_A2/extract_bank_A2.py create mode 100644 Port_Extraction/bank_A3/extract_bank_A3.py create mode 100644 Port_Extraction/bank_A4/extract_bank_A4.py create mode 100644 Port_Extraction/bank_A5/extract_bank_A5.py create mode 100644 Port_Extraction/bank_A6/extract_bank_A6.py create mode 100644 Port_Extraction/bank_A7/extract_bank_A7.py create mode 100644 Port_Extraction/bank_A8/extract_bank_A8.py create mode 100644 Port_Extraction/bank_A9/extract_bank_A9.py create mode 100644 Port_Extraction/bank_AA/extract_bank_AA.py create mode 100644 Port_Extraction/bank_AD/extract_bank_AD.py create mode 100644 Port_Extraction/bank_B2/extract_bank_B2.py create mode 100644 Port_Extraction/bank_B3/extract_bank_B3.py create mode 100644 Port_Extraction/bank_B4/extract_bank_B4.py create mode 100644 Port_Extraction/common_data.py create mode 100644 Port_Extraction/out_92_original.txt diff --git a/Port_Extraction/bank_80/extract_area_elevator_bits.py b/Port_Extraction/bank_80/extract_area_elevator_bits.py new file mode 100644 index 0000000..8c3e4dc --- /dev/null +++ b/Port_Extraction/bank_80/extract_area_elevator_bits.py @@ -0,0 +1,5 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + diff --git a/Port_Extraction/bank_80/extract_bank_80.py b/Port_Extraction/bank_80/extract_bank_80.py new file mode 100644 index 0000000..e3196bd --- /dev/null +++ b/Port_Extraction/bank_80/extract_bank_80.py @@ -0,0 +1,23 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kMusicPointers = [] +kTimerDigitsSpritemapPtr = [] +kLoadStationLists = [] +kAreaElevatorBitsPtr = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_80(): + rom.get_data(0x8F, 0xE7E1, 0xE82C, "LongPtr", kMusicPointers, "kMusicPointers", True, True, -1, 1) + rom.get_data(0x80, 0x9FD4, 0x9FE8, "uint16", kTimerDigitsSpritemapPtr, "kTimerDigitsSpritemapPtr", True, True, -1, 1) + rom.get_data(0x80, 0xC4B5, 0xC4C5, "uint16", kLoadStationLists, "kLoadStationLists", True, True, -1, 1) + rom.get_data(0x80, 0xCD46, 0xCD52, "uint16", kAreaElevatorBitsPtr, "kAreaElevatorBitsPtr", True, True, -1, 1) + return + +get_80() \ No newline at end of file diff --git a/Port_Extraction/bank_81/extract_bank_81.py b/Port_Extraction/bank_81/extract_bank_81.py new file mode 100644 index 0000000..71bd622 --- /dev/null +++ b/Port_Extraction/bank_81/extract_bank_81.py @@ -0,0 +1,492 @@ +import sys + +class Rom: + def __init__(self): + self.data = open('sm.smc', 'rb').read() + + def map(self, addr): + assert addr & 0x8000 + return (((addr >> 16) << 15) | (addr & 0x7fff)) & 0x3fffff + + def get_byte(self, addr): + return self.data[self.map(addr)] + + def get_word(self, addr): + addr = self.map(addr) + return self.data[addr] + self.data[addr + 1] * 256 + + def get_long(self, addr): + addr = self.map(addr) + return self.data[addr] + self.data[addr + 1] * 256 + self.data[addr + 2] * 65536 + + def get_bytes(self, addr, n): + addr = self.map(addr) + return self.data[addr:addr+n] + +ROM = Rom() +get_byte = ROM.get_byte +get_word = ROM.get_word +get_long = ROM.get_long + +class MapScrollArrowData: + def __init__(self, addr): + self.x_pos = get_word(addr) + self.y_pos = get_word(addr+2) + self.anim_id = get_word(addr+4) + self.input = get_word(addr+6) + self.map_scroll_dir = get_word(addr+8) + def __str__(self): + output = "%s, %s, %s, %s, %s, };" % (self.x_pos, self.y_pos, self.anim_id, self.input, self.map_scroll_dir) + return output + +class ExpandingSquareVels: + def __init__(self, addr): + self.left_subvel = get_word(addr) + self.left_vel = get_word(addr+2) + self.right_subvel = get_word(addr+4) + self.right_vel = get_word(addr+6) + self.top_subvel = get_word(addr+8) + self.top_vel = get_word(addr+10) + self.bottom_subvel = get_word(addr+12) + self.bottom_vel = get_word(addr+14) + def __str__(self): + output = "%6s,%6s, %6s,%3s, %6s,%6s, %6s,%3s, " % (hex(self.left_subvel), hex(self.left_vel), hex(self.right_subvel), hex(self.right_vel), + hex(self.top_subvel), hex(self.top_vel), hex(self.bottom_subvel), hex(self.bottom_vel)) + return output + + +bank_81 = 0x810000 + +#SRAM offsets for each save slot +SaveSlotOffset = [] +def getSaveSlotOffset(): + save_slot_offset_address = 0x81812b + end_address = 0x818131 + while save_slot_offset_address != end_address: + get_offset = hex(get_word(save_slot_offset_address)) + SaveSlotOffset.append(get_offset) + save_slot_offset_address += 2 + printSavesSlotOffset() + return + +def printSavesSlotOffset(): + print("uint16 kOffsetToSaveSlot[] = {", end=" ") + for save_slot_offset in SaveSlotOffset: + print(save_slot_offset, end=", ") + print("};") + return + + +#Size of each area map +AreaMapSize = [] +def getAreaMapSize(): + area_map_size_address = 0x818131 + end_address = 0x818138 + while area_map_size_address != end_address: + get_size = get_byte(area_map_size_address) + AreaMapSize.append(get_size) + area_map_size_address += 1 + printAreaMapSize() + return + +def printAreaMapSize(): + print("uint8 kPackedBytesPerArea_Count[] = {", end=" ") + for area_map_size in AreaMapSize: + print(area_map_size, end=", ") + print("};") + return + + +#Offset for each area map +AreaMapOffset = [] +def getAreaMapOffset(): + area_map_offset_address = 0x818138 + end_address = 0x818146 + while area_map_offset_address != end_address: + get_offset = get_word(area_map_offset_address) + AreaMapOffset.append(get_offset) + area_map_offset_address += 2 + printAreaMapOffset() + return + +def printAreaMapOffset(): + print("uint16 kPackedBytesPerArea_PackedOffs[] = {", end=" ") + for area_map_offset in AreaMapOffset: + print(area_map_offset, end=", ") + print("};") + return + + +#Pointer to each area's map rooms +MapRoomPtr = [] +def getMapRoomPtr(): + map_room_ptr_address = 0x8182D6 + end_address = 0x8182E4 + while map_room_ptr_address != end_address: + get_ptr = hex(get_word(map_room_ptr_address)) + MapRoomPtr.append(get_ptr) + map_room_ptr_address += 2 + printMapRoomPtr() + return + +def printMapRoomPtr(): + print("uint16 kPackedBytesPerArea_UnpackedOffs[] = {", end=" ") + for map_room in MapRoomPtr: + print(map_room, end=", ") + print("};") + return + + +#Menu palettes +MenuPalettes = [] +def getMenuPalettes(): + menu_palettes_address = 0x8EE400 + end_address = 0x8EE600 + while menu_palettes_address != end_address: + get_menu_palettes = hex(get_word(menu_palettes_address)) + MenuPalettes.append(get_menu_palettes) + menu_palettes_address += 2 + printMenuPalettes() + return + +def printMenuPalettes(): + print("uint16 kMenuPalettes[] = {", end=" ") + new_line_counter = 0 + for menu_palettes in MenuPalettes: + if new_line_counter == 16: + print("\n\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % menu_palettes, end=", ") + new_line_counter += 1 + print("};") + return + + +#Zebes and stars tilemap +ZebesStarsTilemap = [] +def getZebesStarsTilemap(): + zebes_stars_tilemap_address = 0x8EDC00 + end_address = 0x8EE400 + while zebes_stars_tilemap_address != end_address: + get_zebes_stars_tilemap = hex(get_word(zebes_stars_tilemap_address)) + ZebesStarsTilemap.append(get_zebes_stars_tilemap) + zebes_stars_tilemap_address += 2 + printZebesStarsTilemap() + return + +def printZebesStarsTilemap(): + print("uint16 kZebesAndStarsTilemap[] = {", end=" ") + new_line_counter = 0 + for zebes_stars_tilemap in ZebesStarsTilemap: + if new_line_counter == 32: + print("\n\t\t\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % zebes_stars_tilemap, end=", ") + new_line_counter += 1 + print("};") + return + + +#Area select map foreground palettes offsets +AreaMapForegroundPalettesOffset = [] +def getAreaMapForegroundPalettesOffset(): + offset_address = 0x81A4E6 + end_address = 0x81A546 + while offset_address != end_address: + get_offset = hex(get_word(offset_address)) + AreaMapForegroundPalettesOffset.append(get_offset) + offset_address += 2 + printAreaMapForegroundPalettesOffset() + return + +def printAreaMapForegroundPalettesOffset(): + print("uint16 kAreaMapForegroundSetDefs[] = {", end=" ") + new_line_counter = 0 + for offset in AreaMapForegroundPalettesOffset: + if new_line_counter == 2: + print("\n\t\t\t\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % offset, end=", ") + if offset == "0xffff": + new_line_counter = 2 + continue + new_line_counter += 1 + print("};") + return + + +#Area select map foreground palettes +AreaMapForegroundPalettes = [] +def getAreaMapForegroundPalettes(): + palette_address = 0x81A40E + end_address = 0x81A4CE + while palette_address != end_address: + get_palette = hex(get_word(palette_address)) + AreaMapForegroundPalettes.append(get_palette) + palette_address += 2 + printAreaMapForegroundPalettes() + return + +def printAreaMapForegroundPalettes(): + print("uint16 kAreaMapForegroundColors[] = {", end=" ") + new_line_counter = 0 + for palette in AreaMapForegroundPalettes: + if new_line_counter == 16: + print("\n\t\t\t\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % palette, end=", ") + new_line_counter += 1 + print("};") + return + + +#Tilemap - BG2 pause screen / BG2 room select map +Bg2PauseScreenRoomSelectTilemap = [] +def getBg2PauseScreenRoomSelectTilemap(): + tilemap_address = 0xB6E000 + end_address = 0xB6E800 + while tilemap_address != end_address: + get_tilemap = hex(get_word(tilemap_address)) + Bg2PauseScreenRoomSelectTilemap.append(get_tilemap) + tilemap_address += 2 + printBg2PauseScreenRoomSelectTilemap() + return + +def printBg2PauseScreenRoomSelectTilemap(): + print("uint16 kBg2RoomSelectMapTilemap[] = {", end=" ") + new_line_counter = 0 + for tilemap in Bg2PauseScreenRoomSelectTilemap: + if new_line_counter == 32: + print("\n\t\t\t\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % tilemap, end=", ") + new_line_counter += 1 + print("};") + return + + +#Tilemap - room select map controls +RoomSelectMapControlsTilemap = [] +def getRoomSelectMapControlsTilemap(): + tilemap_address = 0x81B14B + end_address = 0x81B2CB + while tilemap_address != end_address: + get_tilemap = hex(get_word(tilemap_address)) + RoomSelectMapControlsTilemap.append(get_tilemap) + tilemap_address += 2 + printRoomSelectMapControlsTilemap() + return + +def printRoomSelectMapControlsTilemap(): + print("uint16 kFileSelectExpandingSquareTilemap[] = {", end=" ") + new_line_counter = 0 + for tilemap in RoomSelectMapControlsTilemap: + if new_line_counter == 32: + print("\n\t\t\t\t\t\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % tilemap, end=", ") + new_line_counter += 1 + print("};") + return + + +#Map icon data pointers +MapIconDataPointer = [] +def getMapIconDataPointer(): + data_ptr = 0x82C7CB + end_address = 0x82C83B + while data_ptr != end_address: + get_ptr = hex(get_word(data_ptr)) + MapIconDataPointer.append(get_ptr) + data_ptr += 2 + printMapIconDataPointer() + return + +def printMapIconDataPointer(): + print("MapIconDataPointers kMapIconDataPointers[] = {", end=" ") + new_line_counter = 0 + for data_ptr in MapIconDataPointer: + if new_line_counter == 8: + print("\n\t\t\t\t\t\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % data_ptr, end=", ") + new_line_counter += 1 + print("};") + return + + +#Area select spritemap base index +AreaSelectSpritemapBaseIndex = [] +def getAreaSelectSpritemapBaseIndex(): + index_ptr = 0x82C749 + get_index = hex(get_word(index_ptr)) + AreaSelectSpritemapBaseIndex.append(get_index) + printAreaSelectSpritemapBaseIndex() + return + +def printAreaSelectSpritemapBaseIndex(): + print("uint16 gAreaSelectSpritemapOffset[] = {", end=" ") + for index in AreaSelectSpritemapBaseIndex: + print(index, end=" ") + print("};") + return + + +#Map scroll arrow data +FileSelectLeftMapScrollArrowData = [] +FileSelectRightMapScrollArrowData = [] +FileSelectUpMapScrollArrowData = [] +FileSelectDownMapScrollArrowData = [] +def getFileSelectMapScrollArrowData(): + map_arrow_data = 0x81AF32 + new_data = MapScrollArrowData(map_arrow_data) + FileSelectLeftMapScrollArrowData.append(new_data) + map_arrow_data += 10 + new_data = MapScrollArrowData(map_arrow_data) + FileSelectRightMapScrollArrowData.append(new_data) + map_arrow_data += 10 + new_data = MapScrollArrowData(map_arrow_data) + FileSelectUpMapScrollArrowData.append(new_data) + map_arrow_data += 10 + new_data = MapScrollArrowData(map_arrow_data) + map_arrow_data += 10 + FileSelectDownMapScrollArrowData.append(new_data) + printFileSelectMapScrollArrowData() + return + +def printFileSelectMapScrollArrowData(): + for data in FileSelectLeftMapScrollArrowData: + print("MapScrollArrowData kFileSelectLeftMapScrollArrowData = {", end=" ") + print(data) + for data in FileSelectRightMapScrollArrowData: + print("MapScrollArrowData kFileSelectRightMapScrollArrowData = {", end=" ") + print(data) + for data in FileSelectUpMapScrollArrowData: + print("MapScrollArrowData kFileSelectUpMapScrollArrowData = {", end=" ") + print(data) + for data in FileSelectDownMapScrollArrowData: + print("MapScrollArrowData kFileSelectDownMapScrollArrowData = {", end=" ") + print(data) + return + + +#Spritemap pointers +MenuSpritemapPtr = [] +def getGeneralMenuSpritemap(): + spritemap_ptr_address = 0x82C569 + end_address = 0x82C639 + while spritemap_ptr_address != end_address: + get_spritemap_ptr = hex(get_word(spritemap_ptr_address)) + MenuSpritemapPtr.append(get_spritemap_ptr) + spritemap_ptr_address += 2 + printGeneralMenuSpritemap() + return + +def printGeneralMenuSpritemap(): + print("uint16 gMenuSpritemapTable[] = {", end=" ") + new_line_counter = 0 + for spritemap_ptr in MenuSpritemapPtr: + if new_line_counter == 16: + print("\n\t\t\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % spritemap_ptr, end=", ") + new_line_counter += 1 + print("};") + return + + +#Samus spritemap table +SamusSpritemapTable = [] +def getSamusSpritemapPtrs(): + spritemap_ptr = 0x92808D + end_address = 0x9290ED + while spritemap_ptr != end_address: + get_ptr = hex(get_word(spritemap_ptr)) + SamusSpritemapTable.append(get_ptr) + spritemap_ptr += 2 + SamusSpritemapTable.append(hex(0x9173)) + printSamusSpritemapTable() + return + +def printSamusSpritemapTable(): + print("uint16 kSamusSpritemapTable[] = {", end=" ") + new_line_counter = 0 + for spritemap_ptr in SamusSpritemapTable: + if new_line_counter == 16: + print("\n\t\t\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % spritemap_ptr, end=", ") + new_line_counter += 1 + print("};") + return + + +#Flare spritemap pointers +FlareSpritemapPtr = [] +def getFlareSpritemapPtr(): + spritemap_ptr_address = 0x93A1A1 + end_address = 0x93A225 + while spritemap_ptr_address != end_address: + get_spritemap_ptr = hex(get_word(spritemap_ptr_address)) + FlareSpritemapPtr.append(get_spritemap_ptr) + spritemap_ptr_address += 2 + printFlareSpritemapPtr() + return + +def printFlareSpritemapPtr(): + print("uint16 gFlareSpritemapTable[] = {", end=" ") + new_line_counter = 0 + for spritemap_ptr in FlareSpritemapPtr: + if new_line_counter == 16: + print("\n\t\t\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % spritemap_ptr, end=", ") + new_line_counter += 1 + print("};") + return + + +#Room select map expanding square velocities +MapExpandVel = [] +def getMapExpandVel(): + vel_address = 0x81AA34 + end_address = 0x81AA94 + while vel_address != end_address: + new_vel = ExpandingSquareVels(vel_address) + MapExpandVel.append(new_vel) + vel_address += 16 + printMapExpandVel() + return + +def printMapExpandVel(): + print("ExpandingSquareVels kExpandingSquareVels[] = {", end= " ") + new_line_counter = 0 + for vel in MapExpandVel: + if new_line_counter > 0: + print("\t\t\t\t\t\t\t\t\t\t\t ", end="") + print(vel) + new_line_counter += 1 + print("};") + return + + +def getAll(): + getSaveSlotOffset() + getAreaMapSize() + getAreaMapOffset() + getMapRoomPtr() + getMenuPalettes() + getZebesStarsTilemap() + getAreaMapForegroundPalettesOffset() + getAreaMapForegroundPalettes() + getBg2PauseScreenRoomSelectTilemap() + getRoomSelectMapControlsTilemap() + getMapIconDataPointer() + getAreaSelectSpritemapBaseIndex() + getFileSelectMapScrollArrowData() + getGeneralMenuSpritemap() + getSamusSpritemapPtrs() + getFlareSpritemapPtr() + getMapExpandVel() + +getAll() \ No newline at end of file diff --git a/Port_Extraction/bank_82/extract_bank_82.py b/Port_Extraction/bank_82/extract_bank_82.py new file mode 100644 index 0000000..17f3c88 --- /dev/null +++ b/Port_Extraction/bank_82/extract_bank_82.py @@ -0,0 +1,1057 @@ +import sys + +class Rom: + def __init__(self): + self.data = open('sm.smc', 'rb').read() + + def map(self, addr): + assert addr & 0x8000 + return (((addr >> 16) << 15) | (addr & 0x7fff)) & 0x3fffff + + def get_byte(self, addr): + return self.data[self.map(addr)] + + def get_word(self, addr): + addr = self.map(addr) + return self.data[addr] + self.data[addr + 1] * 256 + + def get_long(self, addr): + addr = self.map(addr) + return self.data[addr] + self.data[addr + 1] * 256 + self.data[addr + 2] * 65536 + + def get_bytes(self, addr, n): + addr = self.map(addr) + return self.data[addr:addr+n] + +ROM = Rom() +get_byte = ROM.get_byte +get_word = ROM.get_word +get_long = ROM.get_long + +bank_82 = 0x820000 + +class PauseScreenSpriteAnimationData: + def __init__(self, addr): + self.unused_1 = get_word(addr) + self.lr_highlight = get_word(addr+2) + self.item_selector = get_word(addr+4) + self.unused_2 = get_word(addr+6) + self.unused_3 = get_word(addr+8) + self.map_scroll_arrow_up = get_word(addr+10) + self.map_scroll_arrow_down = get_word(addr+12) + self.map_scroll_arrow_right = get_word(addr+14) + self.map_scroll_arrow_left = get_word(addr+16) + def __str__(self): + output = "%6s, %6s, %6s, %6s, %6s, %6s, %6s, %6s, %6s, };" % (hex(self.unused_1), hex(self.lr_highlight), hex(self.item_selector), hex(self.unused_2), + hex(self.unused_3), hex(self.map_scroll_arrow_up), hex(self.map_scroll_arrow_down), + hex(self.map_scroll_arrow_right), hex(self.map_scroll_arrow_left),) + return output + +class MapScrollArrowData: + def __init__(self, addr): + self.x_pos = get_word(addr) + self.y_pos = get_word(addr+2) + self.anim_id = get_word(addr+4) + self.input = get_word(addr+6) + self.map_scroll_dir = get_word(addr+8) + def __str__(self): + output = "%s, %s, %s, %s, %s, };" % (self.x_pos, self.y_pos, self.anim_id, self.input, self.map_scroll_dir) + return output + +class FileCopyArrowStuff: + def __init__(self, addr): + self.spritemap_index = get_word(addr) + self.x_pos = get_word(addr+2) + self.y_pos = get_word(addr+4) + def __str__(self): + output = "%s, %s, %s, " % (self.spritemap_index, self.x_pos, self.y_pos) + return output + + +#Pointers to demo room data +DemoRoomDataPtr = [] +def getDemoRoomDataPtr(): + ptr_address = 0x82876C + end_address = 0x828774 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + DemoRoomDataPtr.append(get_ptr) + ptr_address += 2 + printDemoRoomDataPtr() + return + +def printDemoRoomDataPtr(): + print("uint16 kDemoRoomData[] = {", end=" ") + for ptr in DemoRoomDataPtr: + print(ptr, end=", ") + print("};") + return + + +#Pause screen sprite animation data +PauseScreenSpriteAnimTimer = [] +PauseScreenSpriteAnimFrame = [] +PauseScreenSpriteAnimMode = [] +PauseScreenSpriteAnimData = [] +def getPauseScreenSpriteAnim(): + ptr_address = 0x82C0B2 + new_data = PauseScreenSpriteAnimationData(ptr_address) + PauseScreenSpriteAnimTimer.append(new_data) + ptr_address += 18 + new_data = PauseScreenSpriteAnimationData(ptr_address) + PauseScreenSpriteAnimFrame.append(new_data) + ptr_address += 18 + new_data = PauseScreenSpriteAnimationData(ptr_address) + PauseScreenSpriteAnimMode.append(new_data) + ptr_address += 18 + new_data = PauseScreenSpriteAnimationData(ptr_address) + PauseScreenSpriteAnimData.append(new_data) + printPauseScreenSpriteAnim() + return + +def printPauseScreenSpriteAnim(): + for data in PauseScreenSpriteAnimTimer: + print("PauseScreenSpriteAnimationData kPauseScreenSpriteAnimationData_Timer = {", end=" ") + print(data) + for data in PauseScreenSpriteAnimFrame: + print("PauseScreenSpriteAnimationData kPauseScreenSpriteAnimationData_Frame = {", end=" ") + print(data) + for data in PauseScreenSpriteAnimMode: + print("PauseScreenSpriteAnimationData kPauseScreenSpriteAnimationData_Mode = {", end=" ") + print(data) + for data in PauseScreenSpriteAnimData: + print("PauseScreenSpriteAnimationData kPauseScreenSpriteAnimationData_Data = {", end=" ") + print(data) + return + + +#Sprite palette index values +SpritePaletteIndexValue = [] +def getSpritePaletteIndexValue(): + index_address = 0x82C0FA + end_address = 0x82C10A + while index_address != end_address: + get_index = hex(get_word(index_address)) + SpritePaletteIndexValue.append(get_index) + index_address += 2 + printSpritePaletteIndexValue() + return + +def printSpritePaletteIndexValue(): + print("uint16 kPauseSpritePaletteIndexValues[] = {", end=" ") + for index in SpritePaletteIndexValue: + print(index, end=", ") + print("};") + return + + +#Pointers to animation spritemap base IDs (into $82:C569 table) +GeneralMenuAnimationSpritemapBaseIdPtr = [] +def getGeneralMenuAnimationSpritemapBaseIdPtr(): + ptr_address = 0x82C1E4 + end_address = 0x82C1F6 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + GeneralMenuAnimationSpritemapBaseIdPtr.append(get_ptr) + ptr_address += 2 + printGeneralMenuAnimationSpritemapBaseIdPtr() + return + +def printGeneralMenuAnimationSpritemapBaseIdPtr(): + print("uint16 kPausePtsToAnimationSpritemapBaseIds[] = {", end=" ") + for ptr in GeneralMenuAnimationSpritemapBaseIdPtr: + print(ptr, end=", ") + print("};") + return + + +#Initial palette +InitialPalette = [] +def getInitialPalette(): + palette_address = 0x9A8000 + end_address = 0x9A8200 + while palette_address != end_address: + get_palette = hex(get_word(palette_address)) + InitialPalette.append(get_palette) + palette_address += 2 + printInitialPalette() + return + +def printInitialPalette(): + print("uint16 kInitialPalette[] = {", end=" ") + new_line_counter = 0 + for palette in InitialPalette: + if new_line_counter == 16: + print("\n\t\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % palette, end=", ") + new_line_counter += 1 + print("};") + return + + +#Palettes - pause screen +PauseScreenPalette = [] +def getPauseScreenPalette(): + palette_address = 0xB6F000 + end_address = 0xB6F200 + while palette_address != end_address: + get_palette = hex(get_word(palette_address)) + PauseScreenPalette.append(get_palette) + palette_address += 2 + printPauseScreenPalette() + return + +def printPauseScreenPalette(): + print("uint16 kPauseScreenPalettes[] = {", end=" ") + new_line_counter = 0 + for palette in PauseScreenPalette: + if new_line_counter == 16: + print("\n\t\t\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % palette, end=", ") + new_line_counter += 1 + print("};") + return + + +#L/R highlight animation data / pause screen palette animation delays +LRHighlightAnimData = [] +def getLRHighlightAnimData(): + data_address = 0x82C10C + end_address = 0x82C137 + while data_address != end_address: + get_data = get_byte(data_address) + LRHighlightAnimData.append(get_data) + data_address += 1 + printLRHighlightAnimData() + return + +def printLRHighlightAnimData(): + print("uint8 kPauseLrHighlightAnimData[] = {", end=" ") + new_space_counter = 0 + for data in LRHighlightAnimData: + if new_space_counter == 3: + print(" ", end="") + new_space_counter = 0 + print(data, end=",") + new_space_counter += 1 + print("};") + return + + +#Area label tilemaps +AreaLabelTilemapPtr = [] +def getAreaLabelTilemapPtr(): + ptr_address = 0x82965F + end_address = 0x82966F + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + AreaLabelTilemapPtr.append(get_ptr) + ptr_address += 2 + printAreaLabelTilemapPtr() + return + +def printAreaLabelTilemapPtr(): + print("uint16 kPauseAreaLabelTilemap[] = {", end=" ") + for ptr in AreaLabelTilemapPtr: + print(ptr, end=", ") + print("};") + return + + +#Pointers to area maps +AreaMapPtr = [] +def getAreaMapPtr(): + ptr_address = 0x82964A + end_address = 0x82965F + while ptr_address != end_address: + #get_ptr = hex(get_long(ptr_address)) + #AreaMapPtr.append(get_ptr) + #ptr_address += 3 + get_ptr_address = hex(get_word(ptr_address)) + AreaMapPtr.append(get_ptr_address) + ptr_address += 2 + get_ptr_bank = hex(get_byte(ptr_address)) + AreaMapPtr.append(get_ptr_bank) + ptr_address += 1 + printAreaMapPtr() + return + +def printAreaMapPtr(): + print("LongPtr kPauseMenuMapTilemaps[] = {", end=" ") + for ptr in AreaMapPtr: + print(ptr, end=", ") + print("};") + return + + +#Map data pointers +MapDataPtr = [] +def getMapDataPtr(): + ptr_address = 0x829717 + end_address = 0x829727 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + MapDataPtr.append(get_ptr) + ptr_address += 2 + printMapDataPtr() + return + +def printMapDataPtr(): + print("uint16 kPauseMenuMapData[] = {", end=" ") + for ptr in MapDataPtr: + print(ptr, end=", ") + print("};") + return + + +#Pointers to equipment tilemaps +TanksEquipmentTilemap = [] +def getTanksEquipmentTilemap(): + ptr_address = 0x82C088 + end_address = 0x82C08C + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + TanksEquipmentTilemap.append(get_ptr) + ptr_address += 2 + printTanksEquipmentTilemap() + return + +def printTanksEquipmentTilemap(): + print("uint16 kEquipmentTilemaps_Tanks[] = {", end=" ") + for ptr in TanksEquipmentTilemap: + print(ptr, end=", ") + print("};") + return + + +WeaponsEquipmentTilemap = [] +def getWeaponsEquipmentTilemap(): + ptr_address = 0x82C08C + end_address = 0x82C096 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + WeaponsEquipmentTilemap.append(get_ptr) + ptr_address += 2 + printWeaponsEquipmentTilemap() + return + +def printWeaponsEquipmentTilemap(): + print("uint16 kEquipmentTilemaps_Weapons[] = {", end=" ") + for ptr in WeaponsEquipmentTilemap: + print(ptr, end=", ") + print("};") + return + + +SuitsEquipmentTilemap = [] +def getSuitsEquipmentTilemap(): + ptr_address = 0x82C096 + end_address = 0x82C0A2 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + SuitsEquipmentTilemap.append(get_ptr) + ptr_address += 2 + printSuitsEquipmentTilemap() + return + +def printSuitsEquipmentTilemap(): + print("uint16 kEquipmentTilemaps_Suits[] = {", end=" ") + for ptr in SuitsEquipmentTilemap: + print(ptr, end=", ") + print("};") + return + + +BootsEquipmentTilemap = [] +def getBootsEquipmentTilemap(): + ptr_address = 0x82C0A2 + end_address = 0x82C0A8 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + BootsEquipmentTilemap.append(get_ptr) + ptr_address += 2 + printBootsEquipmentTilemap() + return + +def printBootsEquipmentTilemap(): + print("uint16 kEquipmentTilemaps_Boots[] = {", end=" ") + for ptr in BootsEquipmentTilemap: + print(ptr, end=", ") + print("};") + return + + +HyperEquipmentTilemap = [] +def getHyperEquipmentTilemap(): + ptr_address = 0x82C0A8 + end_address = 0x82C0B2 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + HyperEquipmentTilemap.append(get_ptr) + ptr_address += 2 + printHyperEquipmentTilemap() + return + +def printHyperEquipmentTilemap(): + print("uint16 kHyperBeamWeaponsTilemaps[] = {", end=" ") + for ptr in HyperEquipmentTilemap: + print(ptr, end=", ") + print("};") + return + + +#Equipment bitmasks +WeaponsEquipmentBitmask = [] +def getWeaponsEquipmentBitmask(): + bitmask_address = 0x82C04C + end_address = 0x82C056 + while bitmask_address != end_address: + get_bitmask = hex(get_word(bitmask_address)) + WeaponsEquipmentBitmask.append(get_bitmask) + bitmask_address += 2 + printWeaponsEquipmentBitmask() + return + +def printWeaponsEquipmentBitmask(): + print("uint16 kEquipmentBitmasks_Weapons[] = {", end=" ") + for bitmask in WeaponsEquipmentBitmask: + print(bitmask, end=", ") + print("};") + return + + +SuitsEquipmentBitmask = [] +def getSuitsEquipmentBitmask(): + bitmask_address = 0x82C056 + end_address = 0x82C062 + while bitmask_address != end_address: + get_bitmask = hex(get_word(bitmask_address)) + SuitsEquipmentBitmask.append(get_bitmask) + bitmask_address += 2 + printSuitsEquipmentBitmask() + return + +def printSuitsEquipmentBitmask(): + print("uint16 kEquipmentBitmasks_Suits[] = {", end=" ") + for bitmask in SuitsEquipmentBitmask: + print(bitmask, end=", ") + print("};") + return + + +BootsEquipmentBitmask = [] +def getBootsEquipmentBitmask(): + bitmask_address = 0x82C062 + end_address = 0x82C068 + while bitmask_address != end_address: + get_bitmask = hex(get_word(bitmask_address)) + BootsEquipmentBitmask.append(get_bitmask) + bitmask_address += 2 + printBootsEquipmentBitmask() + return + +def printBootsEquipmentBitmask(): + print("uint16 kEquipmentBitmasks_Boots[] = {", end=" ") + for bitmask in BootsEquipmentBitmask: + print(bitmask, end=", ") + print("};") + return + + +#Pause screen animation palette data +PauseScreenAnimPaletteData = [] +def getPauseScreenAnimPaletteData(): + palette_address = 0x82A987 + end_address = 0x82AB47 + while palette_address != end_address: + get_palette = hex(get_word(palette_address)) + PauseScreenAnimPaletteData.append(get_palette) + palette_address += 2 + printPauseScreenAnimPaletteData() + return + +def printPauseScreenAnimPaletteData(): + print("uint16 kPauseAnimatedPalette[] = {", end=" ") + new_line_counter = 0 + for palette in PauseScreenAnimPaletteData: + if new_line_counter == 16: + print("\n\t\t\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % palette, end=", ") + new_line_counter += 1 + print("};") + return + + +#Reserve tank animation data +ReserveTankAnimData = [] +def getReserveTankAnimData(): + data_address = 0x82C165 + end_address = 0x82C182 + while data_address != end_address: + get_data = get_byte(data_address) + ReserveTankAnimData.append(get_data) + data_address += 1 + printReserveTankAnimData() + return + +def printReserveTankAnimData(): + print("uint8 kPauseReserveTankAnimationData[] = {", end=" ") + new_space_counter = 0 + for data in ReserveTankAnimData: + if new_space_counter == 2: + print(" ", end="") + new_space_counter = 0 + print(data, end=",") + new_space_counter += 1 + print("};") + return + + +#RAM tilemap offsets +TanksEquipmentOffset = [] +def getTanksEquipmentOffset(): + offset_address = 0x82C068 + end_address = 0x82C06C + while offset_address != end_address: + get_offset = hex(get_word(offset_address)) + TanksEquipmentOffset.append(get_offset) + offset_address += 2 + printTanksEquipmentOffset() + return + +def printTanksEquipmentOffset(): + print("uint16 kEquipmentTilemapOffs_Tanks[] = {", end=" ") + for offset in TanksEquipmentOffset: + print(offset, end=", ") + print("};") + return + + +WeaponsEquipmentOffset = [] +def getWeaponsEquipmentOffset(): + offset_address = 0x82C06C + end_address = 0x82C076 + while offset_address != end_address: + get_offset = hex(get_word(offset_address)) + WeaponsEquipmentOffset.append(get_offset) + offset_address += 2 + printWeaponsEquipmentOffset() + return + +def printWeaponsEquipmentOffset(): + print("uint16 kEquipmentTilemapOffs_Weapons[] = {", end=" ") + for offset in WeaponsEquipmentOffset: + print(offset, end=", ") + print("};") + return + + +SuitsEquipmentOffset = [] +def getSuitsEquipmentOffset(): + offset_address = 0x82C076 + end_address = 0x82C082 + while offset_address != end_address: + get_offset = hex(get_word(offset_address)) + SuitsEquipmentOffset.append(get_offset) + offset_address += 2 + printSuitsEquipmentOffset() + return + +def printSuitsEquipmentOffset(): + print("uint16 kEquipmentTilemapOffs_Suits[] = {", end=" ") + for offset in SuitsEquipmentOffset: + print(offset, end=", ") + print("};") + return + + +BootsEquipmentOffset = [] +def getBootsEquipmentOffset(): + offset_address = 0x82C082 + end_address = 0x82C088 + while offset_address != end_address: + get_offset = hex(get_word(offset_address)) + BootsEquipmentOffset.append(get_offset) + offset_address += 2 + printBootsEquipmentOffset() + return + +def printBootsEquipmentOffset(): + print("uint16 kEquipmentTilemapOffs_Boots[] = {", end=" ") + for offset in BootsEquipmentOffset: + print(offset, end=", ") + print("};") + return + + +#Samus wireframe item bitmasks +SamusWireframeItemBitmask = [] +def getSamusWireframeItemBitmask(): + bitmask_address = 0x82B257 + end_address = 0x82B25F + while bitmask_address != end_address: + get_bitmask = hex(get_word(bitmask_address)) + SamusWireframeItemBitmask.append(get_bitmask) + bitmask_address += 2 + printSamusWireframeItemBitmask() + return + +def printSamusWireframeItemBitmask(): + print("uint16 kEquipmentScreenWireframeCmp[] = {", end=" ") + for bitmask in SamusWireframeItemBitmask: + print(bitmask, end=", ") + print("};") + return + + +#Samus wireframe item pointers +SamusWireframeItemPtr = [] +def getSamusWireframeItemPtr(): + ptr_address = 0x82B25F + end_address = 0x82B267 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + SamusWireframeItemPtr.append(get_ptr) + ptr_address += 2 + printSamusWireframeItemPtr() + return + +def printSamusWireframeItemPtr(): + print("uint16 kEquipmentScreenWireframePtrs[] = {", end=" ") + for ptr in SamusWireframeItemPtr: + print(ptr, end=", ") + print("};") + return + + +#Pointers to lists of equipment screen item selector positions +ItemSelectPosEquipmentPtr = [] +def getItemSelectPosEquipmentPtr(): + ptr_address = 0x82C18E + end_address = 0x82C196 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + ItemSelectPosEquipmentPtr.append(get_ptr) + ptr_address += 2 + printItemSelectPosEquipmentPtr() + return + +def printItemSelectPosEquipmentPtr(): + print("uint16 kEquipmentScreenPtrsToItemXYpos[] = {", end=" ") + for ptr in ItemSelectPosEquipmentPtr: + print(ptr, end=", ") + print("};") + return + + +#Equipment screen data - Pointers to lists of RAM tilemap offsets +EquipmentScreenRamOffset = [] +def getEquipmentScreenRamOffset(): + offset_address = 0x82C02C + end_address = 0x82C034 + while offset_address != end_address: + get_offset = hex(get_word(offset_address)) + EquipmentScreenRamOffset.append(get_offset) + offset_address += 2 + printEquipmentScreenRamOffset() + return + +def printEquipmentScreenRamOffset(): + print("uint16 kEquipmentPtrsToRamTilemapOffsets[] = {", end=" ") + for offset in EquipmentScreenRamOffset: + print(offset, end=", ") + print("};") + return + + +#Equipment screen data - Pointers to lists of equipment bitmasks +EquipmentScreenBitmaskOffset = [] +def getEquipmentScreenBitmaskOffset(): + bitmask_address = 0x82C034 + end_address = 0x82C03C + while bitmask_address != end_address: + get_bitmask = hex(get_word(bitmask_address)) + EquipmentScreenBitmaskOffset.append(get_bitmask) + bitmask_address += 2 + printEquipmentScreenBitmaskOffset() + return + +def printEquipmentScreenBitmaskOffset(): + print("uint16 kEquipmentPtrsToBitmasks[] = {", end=" ") + for bitmask in EquipmentScreenBitmaskOffset: + print(bitmask, end=", ") + print("};") + return + + +#Equipment screen data - Pointers to equipment bitsets +EquipmentScreenBitsetOffset = [] +def getEquipmentScreenBitsetOffset(): + bitset_address = 0x82C03C + end_address = 0x82C044 + while bitset_address != end_address: + get_bitset = hex(get_word(bitset_address)) + EquipmentScreenBitsetOffset.append(get_bitset) + bitset_address += 2 + printEquipmentScreenBitsetOffset() + return + +def printEquipmentScreenBitsetOffset(): + print("uint16 kEquipmentPtrsToBitsets[] = {", end=" ") + for bitset in EquipmentScreenBitsetOffset: + print(bitset, end=", ") + print("};") + return + + +#Equipment screen data - Pointers to lists of pointers to equipment tilemaps +EquipmentScreenTilemapPtr = [] +def getEquipmentScreenTilemapPtr(): + ptr_address = 0x82C044 + end_address = 0x82C04C + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + EquipmentScreenTilemapPtr.append(get_ptr) + ptr_address += 2 + printEquipmentScreenTilemapPtr() + return + +def printEquipmentScreenTilemapPtr(): + print("uint16 kEquipmentPtrsToEquipmentTilemaps[] = {", end=" ") + for ptr in EquipmentScreenTilemapPtr: + print(ptr, end=", ") + print("};") + return + + +#Map icon data pointers +MapIconDataPointer = [] +def getMapIconDataPointer(): + data_ptr = 0x82C7CB + end_address = 0x82C83B + while data_ptr != end_address: + get_ptr = hex(get_word(data_ptr)) + MapIconDataPointer.append(get_ptr) + data_ptr += 2 + printMapIconDataPointer() + return + +def printMapIconDataPointer(): + print("MapIconDataPointers kMapIconDataPointers[] = {", end=" ") + new_line_counter = 0 + for data_ptr in MapIconDataPointer: + if new_line_counter == 8: + print("\n\t\t\t\t\t\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % data_ptr, end=", ") + new_line_counter += 1 + print("};") + return + + +#Map scroll arrow data +LeftMapScrollArrowData = [] +RightMapScrollArrowData = [] +UpMapScrollArrowData = [] +DownMapScrollArrowData = [] +def getMapScrollArrowData(): + map_arrow_data = 0x82B9A0 + new_data = MapScrollArrowData(map_arrow_data) + LeftMapScrollArrowData.append(new_data) + map_arrow_data += 10 + new_data = MapScrollArrowData(map_arrow_data) + RightMapScrollArrowData.append(new_data) + map_arrow_data += 10 + new_data = MapScrollArrowData(map_arrow_data) + UpMapScrollArrowData.append(new_data) + map_arrow_data += 10 + new_data = MapScrollArrowData(map_arrow_data) + map_arrow_data += 10 + DownMapScrollArrowData.append(new_data) + printMapScrollArrowData() + return + +def printMapScrollArrowData(): + for data in LeftMapScrollArrowData: + print("MapScrollArrowData kLeftMapScrollArrowData = {", end=" ") + print(data) + for data in RightMapScrollArrowData: + print("MapScrollArrowData kRightMapScrollArrowData = {", end=" ") + print(data) + for data in UpMapScrollArrowData: + print("MapScrollArrowData kUpMapScrollArrowData = {", end=" ") + print(data) + for data in DownMapScrollArrowData: + print("MapScrollArrowData kDownMapScrollArrowData = {", end=" ") + print(data) + return + + +#File copy arrow spritemap index +FileCopyArrowIndex = [] +def getFileCopyArrowIndex(): + index_address = 0x82BB0C + end_address = 0x82BB30 + while index_address != end_address: + new_index = FileCopyArrowStuff(index_address) + FileCopyArrowIndex.append(new_index) + index_address += 6 + printFileCopyArrowIndex() + return + +def printFileCopyArrowIndex(): + print("FileCopyArrowStuff file_copy_arrow_stuff[] = {", end=" ") + new_line_counter = 0 + for index in FileCopyArrowIndex: + if new_line_counter > 0: + print("\n\t\t\t\t\t\t\t\t\t\t\t ", end="") + print(index, end="") + new_line_counter += 1 + print("};") + return + + +#Map elevator destinations +MapElevatorDestination = [] +def getMapElevatorDestination(): + destination_address = 0x82C74D + end_address = 0x82C759 + while destination_address != end_address: + get_destination = hex(get_word(destination_address)) + MapElevatorDestination.append(get_destination) + destination_address += 2 + printMapElevatorDestination() + return + +def printMapElevatorDestination(): + print("uint16 kMapElevatorDests[] = {", end=" ") + for destination in MapElevatorDestination: + print(destination, end=", ") + print("};") + return + + +#Tileset pointers +TilesetPtr = [] +def getTilesetPtr(): + ptr_address = 0x8FE7A7 + end_address = 0x8FE7E1 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + TilesetPtr.append(get_ptr) + ptr_address += 2 + printTilesetPtr() + return + +def printTilesetPtr(): + print("uint16 kStateHeaderTileSets[] = {", end=" ") + new_line_counter = 0 + for ptr in TilesetPtr: + if(new_line_counter == 9): + print("\n\t\t\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print(ptr, end=", ") + new_line_counter += 1 + print("};") + return + + +#Standard target sprite palette line 0 (whites and greys for flashing) +FlashingSpritePalette = [] +def getFlashingSpritePalette(): + palette_address = 0x9AFC00 + end_address = 0x9AFC20 + while palette_address != end_address: + get_palette = hex(get_word(palette_address)) + FlashingSpritePalette.append(get_palette) + palette_address += 2 + printFlashingSpritePalette() + return + +def printFlashingSpritePalette(): + print("uint16 kCommonSpritesPalette1[] = {", end=" ") + new_line_counter = 0 + for palette in FlashingSpritePalette: + if new_line_counter == 4: + print("\n\t\t\t\t\t\t\t\t\t", end="") + new_line_counter = 0 + print("%6s" % palette, end=", ") + new_line_counter += 1 + print("};") + return + + +#Menu palettes +MenuPalettes = [] +def getMenuPalettes(): + menu_palettes_address = 0x8EE400 + end_address = 0x8EE600 + while menu_palettes_address != end_address: + get_menu_palettes = hex(get_word(menu_palettes_address)) + MenuPalettes.append(get_menu_palettes) + menu_palettes_address += 2 + printMenuPalettes() + return + +def printMenuPalettes(): + print("uint16 kMenuPalettes[] = {", end=" ") + new_line_counter = 0 + for menu_palettes in MenuPalettes: + if new_line_counter == 16: + print("\n\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % menu_palettes, end=", ") + new_line_counter += 1 + print("};") + return + + +#Special setting RAM addresses +SpecialSettingRamPtr = [] +def getSpecialSettingRamPtr(): + ptr_address = 0x82F0AE + end_address = 0x82F0B2 + while ptr_address != end_address: + get_ram_ptr = hex(get_word(ptr_address)) + SpecialSettingRamPtr.append(get_ram_ptr) + ptr_address += 2 + printSpecialSettingRamPtr() + return + +def printSpecialSettingRamPtr(): + print("uint16 kOptionsMenuSpecialPtrs[] = {", end=" ") + for ram_ptr in SpecialSettingRamPtr: + print(ram_ptr, end=", ") + print("};") + return + + +#Menu Selection Missile - Position Offset +MenuMissilePosPtr = [] +def getMenuMissileStartPos(): + ptr_address = 0x82F2ED + end_address = 0x82F307 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + MenuMissilePosPtr.append(get_ptr) + ptr_address += 2 + printMenuMissileStartPos() + return + +def printMenuMissileStartPos(): + print("uint16 kMenuMissilePtrsToStartPos[] = {", end=" ") + for ptr in MenuMissilePosPtr: + print(ptr, end=", ") + print("};") + return + + +#Configurable controller binding RAM addresses +ControllerBindingRamAddressPtr = [] +def getControllerBindingRamAddressPtr(): + ptr_address = 0x82F54A + end_address = 0x82F558 + while ptr_address != end_address: + get_ram_ptr = hex(get_word(ptr_address)) + ControllerBindingRamAddressPtr.append(get_ram_ptr) + ptr_address += 2 + printControllerBindingRamAddressPtr() + return + +def printControllerBindingRamAddressPtr(): + print("uint16 kControllerBindingRAMAddresses[] = {", end=" ") + for ram_ptr in ControllerBindingRamAddressPtr: + print(ram_ptr, end=", ") + print("};") + return + + +#Game options menu tilemap offsets +GameOptionsTilemapOffset = [] +def getGameOptionsTilemapOffset(): + offset_address = 0x82F639 + end_address = 0x82F647 + while offset_address != end_address: + get_offset = hex(get_word(offset_address)) + GameOptionsTilemapOffset.append(get_offset) + offset_address += 2 + printGameOptionsTilemapOffset() + return + +def printGameOptionsTilemapOffset(): + print("uint16 kOptionsMenuPtrsToTilemapOffsets[] = {", end=" ") + for offset in GameOptionsTilemapOffset: + print(offset, end=", ") + print("};") + return + + +#Controller button tilemap pointers +ControllerButtonTilemapPtr = [] +def getControllerButtonTilemapPtr(): + ptr_address = 0x82F647 + end_address = 0x82F659 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + ControllerButtonTilemapPtr.append(get_ptr) + ptr_address += 2 + printControllerButtonTilemapPtr() + return + +def printControllerButtonTilemapPtr(): + print("uint16 kOptionsMenuPtrsToButtonTilemaps[] = {", end=" ") + for ptr in ControllerButtonTilemapPtr: + print(ptr, end=", ") + print("};") + return + + +def getAll(): + getDemoRoomDataPtr() + getPauseScreenSpriteAnim() + getSpritePaletteIndexValue() + getGeneralMenuAnimationSpritemapBaseIdPtr() + getInitialPalette() + getPauseScreenPalette() + getLRHighlightAnimData() + getAreaLabelTilemapPtr() + getAreaMapPtr() + getMapDataPtr() + getTanksEquipmentTilemap() + getWeaponsEquipmentTilemap() + getSuitsEquipmentTilemap() + getBootsEquipmentTilemap() + getHyperEquipmentTilemap() + getWeaponsEquipmentBitmask() + getSuitsEquipmentBitmask() + getBootsEquipmentBitmask() + getPauseScreenAnimPaletteData() + getReserveTankAnimData() + getTanksEquipmentOffset() + getWeaponsEquipmentOffset() + getSuitsEquipmentOffset() + getBootsEquipmentOffset() + getSamusWireframeItemBitmask() + getSamusWireframeItemPtr() + getItemSelectPosEquipmentPtr() + getEquipmentScreenRamOffset() + getEquipmentScreenBitmaskOffset() + getEquipmentScreenBitsetOffset() + getEquipmentScreenTilemapPtr() + getMapIconDataPointer() + getMapScrollArrowData() + getFileCopyArrowIndex() + getMapElevatorDestination() + getTilesetPtr() + getFlashingSpritePalette() + getMenuPalettes() + getSpecialSettingRamPtr() + getMenuMissileStartPos() + getControllerBindingRamAddressPtr() + getGameOptionsTilemapOffset() + getControllerButtonTilemapPtr() + +getAll() \ No newline at end of file diff --git a/Port_Extraction/bank_84/extract_bank_84.py b/Port_Extraction/bank_84/extract_bank_84.py new file mode 100644 index 0000000..112b162 --- /dev/null +++ b/Port_Extraction/bank_84/extract_bank_84.py @@ -0,0 +1,384 @@ +import sys + +class Rom: + def __init__(self): + self.data = open('sm.smc', 'rb').read() + + def map(self, addr): + assert addr & 0x8000 + return (((addr >> 16) << 15) | (addr & 0x7fff)) & 0x3fffff + + def get_byte(self, addr): + return self.data[self.map(addr)] + + def get_word(self, addr): + addr = self.map(addr) + return self.data[addr] + self.data[addr + 1] * 256 + + def get_long(self, addr): + addr = self.map(addr) + return self.data[addr] + self.data[addr + 1] * 256 + self.data[addr + 2] * 65536 + + def get_bytes(self, addr, n): + addr = self.map(addr) + return self.data[addr:addr+n] + +ROM = Rom() +get_byte = ROM.get_byte +get_word = ROM.get_word +get_long = ROM.get_long + +bank_84 = 0x840000 + + +#Golden Torizo palette 1 +GoldenTorizoPalette1 = [] +def getGoldzenTorizoPalette1(): + palette_address = 0x848032 + end_address = 0x848132 + while palette_address != end_address: + get_palette = hex(get_word(palette_address)) + GoldenTorizoPalette1.append(get_palette) + palette_address += 2 + printGoldzenTorizoPalette1() + return + +def printGoldzenTorizoPalette1(): + print("uint16 kGoldenTorizoPalette1[] = {", end=" ") + new_line_counter = 0 + for palette in GoldenTorizoPalette1: + if new_line_counter == 16: + print("\n\t\t\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % palette, end=", ") + new_line_counter += 1 + print("};\n") + return + + +#Golden Torizo palette 2 +GoldenTorizoPalette2 = [] +def getGoldzenTorizoPalette2(): + palette_address = 0x848132 + end_address = 0x848232 + while palette_address != end_address: + get_palette = hex(get_word(palette_address)) + GoldenTorizoPalette2.append(get_palette) + palette_address += 2 + printGoldzenTorizoPalette2() + return + +def printGoldzenTorizoPalette2(): + print("uint16 kGoldenTorizoPalette2[] = {", end=" ") + new_line_counter = 0 + for palette in GoldenTorizoPalette2: + if new_line_counter == 16: + print("\n\t\t\t\t\t\t\t\t ", end="") + new_line_counter = 0 + print("%6s" % palette, end=", ") + new_line_counter += 1 + print("};\n") + return + + +#Pointers to x-ray block drawing instructions +XrayBlockDrawingInstructionsPtr = [] +def getXrayBlockDrawingInstructionsPtr(): + ptr_address = 0x84839D + end_address = 0x8483AD + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + XrayBlockDrawingInstructionsPtr.append(get_ptr) + ptr_address += 2 + printXrayBlockDrawingInstructionsPtr() + return + +def printXrayBlockDrawingInstructionsPtr(): + print("uint16 kXrayBlockDrawingInstrs[] = {", end=" ") + for ptr in XrayBlockDrawingInstructionsPtr: + print(ptr, end=", ") + print("};\n") + return + + +#Grey door pre-instructions +GreyDoorPreInstructions = [] +def getGreyDoorPreInstructions(): + ptr_address = 0x84BE4B + end_address = 0x84BE59 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + GreyDoorPreInstructions.append(get_ptr) + ptr_address += 2 + printGreyDoorPreInstructions() + return + +def printGreyDoorPreInstructions(): + print("uint16 kGrayDoorPreInstrs[] = {", end=" ") + for ptr in GreyDoorPreInstructions: + print(ptr, end=", ") + print("};\n") + return + + +#Setup - PLM $C836 (downwards gate shotblock) - Instruction list +DownwardsGateShotblockInstructionList = [] +def getDownwardsGateShotblockInstructionList(): + ptr_address = 0x84C70A + end_address = 0x84C71A + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + DownwardsGateShotblockInstructionList.append(get_ptr) + ptr_address += 2 + printDownwardsGateShotblockInstructionList() + return + +def printDownwardsGateShotblockInstructionList(): + print("uint16 kDowardGatePlmListPtrs[] = {", end=" ") + for ptr in DownwardsGateShotblockInstructionList: + print(ptr, end=", ") + print("};\n") + return + + +#Setup - PLM $C836 (downwards gate shotblock) - Block type / BTS for block to the left +DownwardsGateShotblockLeftBts = [] +def getDownwardsGateShotblockLeftBts(): + ptr_address = 0x84C71A + end_address = 0x84C72A + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + DownwardsGateShotblockLeftBts.append(get_ptr) + ptr_address += 2 + printDownwardsGateShotblockLeftBts() + return + +def printDownwardsGateShotblockLeftBts(): + print("uint16 kDowardGateLeftBlockBts[] = {", end=" ") + for ptr in DownwardsGateShotblockLeftBts: + print(ptr, end=", ") + print("};\n") + return + + +#Setup - PLM $C836 (downwards gate shotblock) - Block type / BTS for block to the right +DownwardsGateShotblockRightBts = [] +def getDownwardsGateShotblockRightBts(): + ptr_address = 0x84C72A + end_address = 0x84C73A + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + DownwardsGateShotblockRightBts.append(get_ptr) + ptr_address += 2 + printDownwardsGateShotblockRightBts() + return + +def printDownwardsGateShotblockRightBts(): + print("uint16 kDowardGateRightBlockBts[] = {", end=" ") + for ptr in DownwardsGateShotblockRightBts: + print(ptr, end=", ") + print("};\n") + return + + +#Setup - PLM $C83A (upwards gate shotblock) - Instruction list +UpwardsGateShotblockInstructionList = [] +def getUpwardsGateShotblockInstructionList(): + ptr_address = 0x84C764 + end_address = 0x84C774 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + UpwardsGateShotblockInstructionList.append(get_ptr) + ptr_address += 2 + printUpwardsGateShotblockInstructionList() + return + +def printUpwardsGateShotblockInstructionList(): + print("uint16 kUpwardGatePlmListPtrs[] = {", end=" ") + for ptr in UpwardsGateShotblockInstructionList: + print(ptr, end=", ") + print("};\n") + return + + +#Setup - PLM $C83A (upwards gate shotblock) - Block type / BTS for block to the left +UpwardsGateShotblockLeftBts = [] +def getUpwardsGateShotblockLeftBts(): + ptr_address = 0x84C774 + end_address = 0x84C784 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + UpwardsGateShotblockLeftBts.append(get_ptr) + ptr_address += 2 + printUpwardsGateShotblockLeftBts() + return + +def printUpwardsGateShotblockLeftBts(): + print("uint16 kUpwardGateLeftBlockBts[] = {", end=" ") + for ptr in UpwardsGateShotblockLeftBts: + print(ptr, end=", ") + print("};\n") + return + + +#Setup - PLM $C83A (upwards gate shotblock) - Block type / BTS for block to the right +UpwardsGateShotblockRightBts = [] +def getUpwardsGateShotblockRightBts(): + ptr_address = 0x84C784 + end_address = 0x84C794 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + UpwardsGateShotblockRightBts.append(get_ptr) + ptr_address += 2 + printUpwardsGateShotblockRightBts() + return + +def printUpwardsGateShotblockRightBts(): + print("uint16 kUpwardGateRightBlockBts[] = {", end=" ") + for ptr in UpwardsGateShotblockRightBts: + print(ptr, end=", ") + print("};\n") + return + + +#Setup - PLM $DB44 (sets Metroids cleared states when required) - pre-instructions +MetroidsClearedPreInstructions = [] +def getMetroidsClearedPreInstructions(): + ptr_address = 0x84DB28 + end_address = 0x84DB42 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + MetroidsClearedPreInstructions.append(get_ptr) + ptr_address += 2 + printMetroidsClearedPreInstructions() + return + +def printMetroidsClearedPreInstructions(): + print("uint16 kSetMetroidsClearStatePreInstrs[] = {", end=" ") + for ptr in MetroidsClearedPreInstructions: + print(ptr, end=", ") + print("};\n") + return + + +#Instruction - draw item frame 0 - draw instructions +ItemFrame0DrawInstructions = [] +def getItemFrame0DrawInstructions(): + ptr_address = 0x84E05F + end_address = 0x84E067 + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + ItemFrame0DrawInstructions.append(get_ptr) + ptr_address += 2 + printItemFrame0DrawInstructions() + return + +def printItemFrame0DrawInstructions(): + print("uint16 kDrawItemFrame0DrawInstrs[] = {", end=" ") + for ptr in ItemFrame0DrawInstructions: + print(ptr, end=", ") + print("};\n") + return + + +#Instruction - draw item frame 1 - draw instructions +ItemFrame1DrawInstructions = [] +def getItemFrame1DrawInstructions(): + ptr_address = 0x84E077 + end_address = 0x84E07F + while ptr_address != end_address: + get_ptr = hex(get_word(ptr_address)) + ItemFrame1DrawInstructions.append(get_ptr) + ptr_address += 2 + printItemFrame1DrawInstructions() + return + +def printItemFrame1DrawInstructions(): + print("uint16 kDrawItemFrame1DrawInstrs[] = {", end=" ") + for ptr in ItemFrame1DrawInstructions: + print(ptr, end=", ") + print("};\n") + return + + +#Instruction - load item PLM GFX - VRAM addresses +PlmGfxVramAddress = [] +def getPlmVramAddress(): + vram_ptr_address = 0x8487CD + end_address = 0x8487D5 + while vram_ptr_address != end_address: + get_vram_ptr = hex(get_word(vram_ptr_address)) + PlmGfxVramAddress.append(get_vram_ptr) + vram_ptr_address += 2 + printPlmVramAddress() + return + +def printPlmVramAddress(): + print("uint16 kPlmVramAddresses[] = {", end=" ") + for vram_ptr in PlmGfxVramAddress: + print(vram_ptr, end=", ") + print("};\n") + return + + +#Instruction - load item PLM GFX - Tile data offsets +PlmGfxVramTileDataOffset = [] +def getPlmVramTileDataOffset(): + offset_address = 0x8487D5 + end_address = 0x8487DD + while offset_address != end_address: + get_offset = hex(get_word(offset_address)) + PlmGfxVramTileDataOffset.append(get_offset) + offset_address += 2 + printPlmVramTileDataOffset() + return + +def printPlmVramTileDataOffset(): + print("uint16 kPlmTileDataOffs[] = {", end=" ") + for offset in PlmGfxVramTileDataOffset: + print(offset, end=", ") + print("};\n") + return + + +#Instruction - load item PLM GFX - Starting tile numbers +PlmGfxVramStartingTile = [] +def getPlmVramStartingTile(): + start_address = 0x8487DD + end_address = 0x8487E5 + while start_address != end_address: + get_start = hex(get_word(start_address)) + PlmGfxVramStartingTile.append(get_start) + start_address += 2 + printPlmVramStartingTile() + return + +def printPlmVramStartingTile(): + print("uint16 kPlmStartingTileNumber[] = {", end=" ") + for start in PlmGfxVramStartingTile: + print(start, end=", ") + print("};\n") + return + + + + +def getAll(): + getGoldzenTorizoPalette1() + getGoldzenTorizoPalette2() + getXrayBlockDrawingInstructionsPtr() + getGreyDoorPreInstructions() + getDownwardsGateShotblockInstructionList() + getDownwardsGateShotblockLeftBts() + getDownwardsGateShotblockRightBts() + getUpwardsGateShotblockInstructionList() + getUpwardsGateShotblockLeftBts() + getUpwardsGateShotblockRightBts() + getMetroidsClearedPreInstructions() + getItemFrame0DrawInstructions() + getItemFrame1DrawInstructions() + getPlmVramAddress() + getPlmVramTileDataOffset() + getPlmVramStartingTile() + +getAll() \ No newline at end of file diff --git a/Port_Extraction/bank_85/extract_bank_85.py b/Port_Extraction/bank_85/extract_bank_85.py new file mode 100644 index 0000000..7fd4649 --- /dev/null +++ b/Port_Extraction/bank_85/extract_bank_85.py @@ -0,0 +1,68 @@ +import sys + +class Rom: + def __init__(self): + self.data = open('sm.smc', 'rb').read() + + def map(self, addr): + assert addr & 0x8000 + return (((addr >> 16) << 15) | (addr & 0x7fff)) & 0x3fffff + + def get_byte(self, addr): + return self.data[self.map(addr)] + + def get_word(self, addr): + addr = self.map(addr) + return self.data[addr] + self.data[addr + 1] * 256 + + def get_long(self, addr): + addr = self.map(addr) + return self.data[addr] + self.data[addr + 1] * 256 + self.data[addr + 2] * 65536 + + def get_bytes(self, addr, n): + addr = self.map(addr) + return self.data[addr:addr+n] + +ROM = Rom() +get_byte = ROM.get_byte +get_word = ROM.get_word +get_long = ROM.get_long + +bank_85 = 0x850000 + +class MsgBoxConfig: + def __init__(self, addr): + self.modify_box_func = get_word(addr) + self.draw_initial_tilemap = get_word(addr+2) + self.message_tilemap = get_word(addr+4) + def __str__(self): + output = "%6s, %6s, %6s, " % (hex(self.modify_box_func), hex(self.draw_initial_tilemap), hex(self.message_tilemap)) + return output + + +#Message definitions +MessageDefinition = [] +def getMessageDefinition(): + msg_def_address = 0x85869B + end_address = 0x858749 + while msg_def_address != end_address: + new_def = MsgBoxConfig(msg_def_address) + MessageDefinition.append(new_def) + msg_def_address += 6 + printMessageDefinition() + return + +def printMessageDefinition(): + print("MsgBoxConfig kMessageBoxDefs[] = {", end=" ") + for msg_def in MessageDefinition: + print(msg_def, end="\n\t\t\t\t\t\t\t\t ") + print("};") + return + + +def getAll(): + getMessageDefinition() + + +getAll() + diff --git a/Port_Extraction/bank_86/extract_bank_86.py b/Port_Extraction/bank_86/extract_bank_86.py new file mode 100644 index 0000000..c10e90b --- /dev/null +++ b/Port_Extraction/bank_86/extract_bank_86.py @@ -0,0 +1,75 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + + +kScreenShakeOffsets = [] +kAlignYPos_Tab0 = [] +kAlignXPos_Tab1 = [] +kGarbageInstrList = [] +kCrocomireSpikeWallPieces_Ypos = [] +kBombTorizoLowHealthDroolInstrlist = [] +kBB50InstrListPtrs_UNUSED = [] +kCommonEnemySpeeds_Quadratic_Copy = [] +kCommonEnemySpeeds_Quadratic32 = [] +kMotherBrainsDeathExplosionInstrListPtrs = [] +kCrocomireProjectile_Ypos = [] +kGunshipLiftoffDustCloudsInstrListPtrs = [] +kEprojInit_BombTorizoStatueBreaking_InstrList = [] +kGoldenTorizoSuperMissileInstrListPtrs = [] +kEproj_MotherBrainRoomTurrets_DirectionIndexes = [] +kEproj_MotherBrainRoomTurrets_AllowedRotations = [] +kEproj_MotherBrainRoomTurrets_InstrLists = [] +kEproj_MotherBrainRoomTurrets_InstrLists_FaceDir = [] +kEprojInit_MotherBrainGlassShatteringShard_InstrPtrs = [] +kEprojInit_N00bTubeShards_InstrPtrs = [] +kEprojInit_SpikeShootingPlantSpikes_InstrList = [] +kSporeMovementData = [] +kEprojInit_NamiFuneFireball_XYvels = [] +kEprojInit_DustCloudOrExplosion_InstrLists = [] +kEprojInit_EyeDoorSmoke_XYpos = [] +kEprojInit_BotwoonsBody_InstrLists = [] +kEprojInit_Pickup_InstrLists = [] +kEprojInit_EnemyDeathExplosion_InstrLists = [] +kEprojInit_Sparks_EprojVars = [] + + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get86(): + rom.get_data(0x86, 0x846B, 0x84FB, "uint16", kScreenShakeOffsets, "kScreenShakeOffsets", False, True, 18, -1) + rom.get_data(0x94, 0x8B2B, 0x8D2B, "uint8", kAlignYPos_Tab0, "kAlignYPos_Tab0", False, True, 16, -1) + rom.get_data(0x94, 0x892B, 0x8B2B, "uint8", kAlignXPos_Tab1, "kAlignXPos_Tab1", False, True, 16, -1) + rom.get_data(0x86, 0x8A75, 0x8A7D, "uint16", kGarbageInstrList, "kGarbageInstrList", True, True, -1, 1) + rom.get_data(0x86, 0x9105, 0x9115, "uint16", kCrocomireSpikeWallPieces_Ypos, "kCrocomireSpikeWallPieces_Ypos", True, True, -1, 1) + rom.get_data(0x86, 0xA64D, 0xA65D, "uint16", kBombTorizoLowHealthDroolInstrlist, "kBombTorizoLowHealthDroolInstrlist", True, True, -1, 1) + rom.get_data(0x86, 0xBB1E, 0xBB24, "uint16", kBB50InstrListPtrs_UNUSED, "kBB50InstrListPtrs_UNUSED", True, True, -1, 1) + rom.get_data(0xA0, 0xCBC7, 0xCEBF, "uint16", kCommonEnemySpeeds_Quadratic_Copy, "kCommonEnemySpeeds_Quadratic_Copy", True, True, 16, 4) + rom.get_data(0xA0, 0xCBC7, 0xCEBF, "uint32", kCommonEnemySpeeds_Quadratic32, "kCommonEnemySpeeds_Quadratic32", True, True, 8, 1) + rom.get_data(0x86, 0xC929, 0xC92F, "uint16", kMotherBrainsDeathExplosionInstrListPtrs, "kMotherBrainsDeathExplosionInstrListPtrs", True, True, -1, 1) + rom.get_data(0x86, 0x9059, 0x906B, "uint16", kCrocomireProjectile_Ypos, "kCrocomireProjectile_Ypos", True, True, -1, 3) + rom.get_data(0x86, 0xA2E2, 0xA2EE, "uint16", kGunshipLiftoffDustCloudsInstrListPtrs, "kGunshipLiftoffDustCloudsInstrListPtrs", True, True, -1, 1) + rom.get_data(0x86, 0xA7AB, 0xA7CB, "uint16", kEprojInit_BombTorizoStatueBreaking_InstrList, "kEprojInit_BombTorizoStatueBreaking_InstrList", True, True, -1, 1) + rom.get_data(0x86, 0xB209, 0xB20D, "uint16", kGoldenTorizoSuperMissileInstrListPtrs, "kGoldenTorizoSuperMissileInstrListPtrs", True, True, -1, 1) + rom.get_data(0x86, 0xBEE1, 0xBEF9, "uint16", kEproj_MotherBrainRoomTurrets_DirectionIndexes, "kEproj_MotherBrainRoomTurrets_DirectionIndexes", False, True, -1, 1) + rom.get_data(0x86, 0xBEC9, 0xBEE1, "uint16", kEproj_MotherBrainRoomTurrets_AllowedRotations, "kEproj_MotherBrainRoomTurrets_AllowedRotations", True, True, -1, 1) + rom.get_data(0x86, 0xBEB9, 0xBEC9, "uint16", kEproj_MotherBrainRoomTurrets_InstrLists, "kEproj_MotherBrainRoomTurrets_InstrLists", True, True, -1, 1) + rom.get_data(0x86, 0xC040, 0xC050, "uint16", kEproj_MotherBrainRoomTurrets_InstrLists_FaceDir, "kEproj_MotherBrainRoomTurrets_InstrLists_FaceDir", True, True, -1, 1) + rom.get_data(0x86, 0xCE41, 0xCE61, "uint16", kEprojInit_MotherBrainGlassShatteringShard_InstrPtrs, "kEprojInit_MotherBrainGlassShatteringShard_InstrPtrs", True, True, -1, 1) + rom.get_data(0x86, 0xD760, 0xD774, "uint16", kEprojInit_N00bTubeShards_InstrPtrs, "kEprojInit_N00bTubeShards_InstrPtrs", True, True, -1, 1) + rom.get_data(0x86, 0xD96A, 0xD97E, "uint16", kEprojInit_SpikeShootingPlantSpikes_InstrList, "kEprojInit_SpikeShootingPlantSpikes_InstrList", True, True, -1, 1) + rom.get_data(0x86, 0xDD6C, 0xDE6C, "uint8", kSporeMovementData, "kSporeMovementData", True, True, 16, 2) + rom.get_data(0x86, 0xDEB6, 0xDED6, "uint16", kEprojInit_NamiFuneFireball_XYvels, "kEprojInit_NamiFuneFireball_XYvels", True, True, -1, 2) + rom.get_data(0x86, 0xE42C, 0xE468, "uint16", kEprojInit_DustCloudOrExplosion_InstrLists, "kEprojInit_DustCloudOrExplosion_InstrLists", True, True, 15, 1) + rom.get_data(0x86, 0xE47E, 0xE4A6, "uint16", kEprojInit_EyeDoorSmoke_XYpos, "kEprojInit_EyeDoorSmoke_XYpos", True, True, 4, 1) + rom.get_data(0x86, 0xE9F1, 0xEA31, "uint16", kEprojInit_BotwoonsBody_InstrLists, "kEprojInit_BotwoonsBody_InstrLists", True, True, 8, 1) + rom.get_data(0x86, 0xEF04, 0xEF10, "uint16", kEprojInit_Pickup_InstrLists, "kEprojInit_Pickup_InstrLists", True, True, -1, 1) + rom.get_data(0x86, 0xEFD5, 0xEFDF, "uint16", kEprojInit_EnemyDeathExplosion_InstrLists, "kEprojInit_EnemyDeathExplosion_InstrLists", True, True, -1, 1) + rom.get_data(0x86, 0xF3D4, 0xF3F0, "uint16", kEprojInit_Sparks_EprojVars, "kEprojInit_Sparks_EprojVars", True, True, -1, 2) + return + +get86() \ No newline at end of file diff --git a/Port_Extraction/bank_88/extract_bank_88.py b/Port_Extraction/bank_88/extract_bank_88.py new file mode 100644 index 0000000..e6cf184 --- /dev/null +++ b/Port_Extraction/bank_88/extract_bank_88.py @@ -0,0 +1,42 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + + +#Pointers to code +kPowerBombExplosionFreeSpace = [] +kPowerBombExplosionShapeTopOffset = [] +kPowerBombExplosionColors = [] +kPowerBombPreExplosionColors = [] +kBG3XscrollWave = [] +kHdmaScrollEntrys = [] +kLavaAcidBG2YScrollLongWave = [] +kLavaAcidBG2YScrollShortWave = [] +kBG3RainXvels = [] +kSuitPickupLightBeamCurveWidths = [] +kRainbowBeamHdmaValues = [] +kMorphBallEyeBeamHdmaValues = [] + + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get88(): + rom.get_data(0x88, 0xA206, 0xA286, "uint8", kPowerBombExplosionFreeSpace, "kPowerBombExplosionFreeSpace", True, True, 16, 1) + rom.get_data(0x88, 0xA286, 0xA2A6, "uint8", kPowerBombExplosionShapeTopOffset, "kPowerBombExplosionShapeTopOffset", True, True, 16, 1) + rom.get_data(0x88, 0x8D85, 0x8DE5, "uint8", kPowerBombExplosionColors, "kPowerBombExplosionColors", True, True, 3, 3) + rom.get_data(0x88, 0x9079, 0x90A9, "uint8", kPowerBombPreExplosionColors, "kPowerBombPreExplosionColors", True, True, 3, 3) + rom.get_data(0x88, 0xA938, 0xAD18, "uint16", kBG3XscrollWave, "kBG3XscrollWave", True, True, 16, 1) + rom.get_data(0x88, 0xAEC1, 0xAF7B, "HdmaScrollEntry", kHdmaScrollEntrys, "kHdmaScrollEntrys", True, True, 1, -1) + rom.get_data(0x88, 0xB589, 0xB5A9, "uint16", kLavaAcidBG2YScrollLongWave, "kLavaAcidBG2YScrollLongWave", True, True, 8, 1) + rom.get_data(0x88, 0xB60A, 0xB62A, "uint16", kLavaAcidBG2YScrollShortWave, "kLavaAcidBG2YScrollShortWave", True, True, 8, 1) + rom.get_data(0x88, 0xD992, 0xD99A, "uint16", kBG3RainXvels, "kBG3RainXvels", True, True, 4, 1) + rom.get_data(0x88, 0xE3C9, 0xE449, "uint8", kSuitPickupLightBeamCurveWidths, "kSuitPickupLightBeamCurveWidths", False, True, 16, 1) + rom.get_data(0x88, 0xE833, 0xE8D9, "uint16", kRainbowBeamHdmaValues, "kRainbowBeamHdmaValues", True, True, 8, 1) + rom.get_data(0x88, 0xEA8B, 0xEACB, "uint8", kMorphBallEyeBeamHdmaValues, "kMorphBallEyeBeamHdmaValues", False, True, 4, 1) + return + +get88() \ No newline at end of file diff --git a/Port_Extraction/bank_89/extract_bank_89.py b/Port_Extraction/bank_89/extract_bank_89.py new file mode 100644 index 0000000..dc8b230 --- /dev/null +++ b/Port_Extraction/bank_89/extract_bank_89.py @@ -0,0 +1,27 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + + +kPaletteBlends = [] +kFxTypeTilemapPtrs = [] +kAreaPalFxListPointers = [] +kAreaAnimtilesListPtrs = [] +kCereElevatorShaftMode7TransformationMatrix = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get89(): + rom.get_data(0x89, 0xAA02, 0xAB02, "uint16", kPaletteBlends, "kPaletteBlends", True, True, 16, 1) + rom.get_data(0x83, 0xABF0, 0xAC1E, "uint16", kFxTypeTilemapPtrs, "kFxTypeTilemapPtrs", True, True, 10, 1) + rom.get_data(0x83, 0xAC46, 0xAC56, "uint16", kAreaPalFxListPointers, "kAreaPalFxListPointers", True, True, -1, 1) + rom.get_data(0x83, 0xAC56, 0xAC66, "uint16", kAreaAnimtilesListPtrs, "kAreaAnimtilesListPtrs", True, True, -1, 1) + rom.get_data(0x89, 0xAD5F, 0xAEFD, "uint16", kCereElevatorShaftMode7TransformationMatrix, "kCereElevatorShaftMode7TransformationMatrix", True, True, 3, -1) + return + + +get89() \ No newline at end of file diff --git a/Port_Extraction/bank_8B/extract_bank_8B.py b/Port_Extraction/bank_8B/extract_bank_8B.py new file mode 100644 index 0000000..0cd265b --- /dev/null +++ b/Port_Extraction/bank_8B/extract_bank_8B.py @@ -0,0 +1,70 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + + +kPalettes_Intro = [] +kPalettes_SpaceGunshipCeres = [] +kPalettes_PostCredits = [] +kPalettes_Credits = [] +kPalettes_ZebesExplosion = [] +kPalettes_ZebesExplosionClouds = [] +kInitialIntro_JapaneseTextTilemap = [] +kPage1Intro_JapaneseTextRegion = [] +kLevelData_MotherBrainRoomFromCutscene = [] +kLevelData_RoomWithBabyMetroidHatching = [] +kCredits_DeerForceTilemap = [] +kCredits_1994NintendoCredits = [] +kPalettes_EndingSuperMetroidIconGlare = [] +kCredits_ItemPercentageRamAddresses = [] +kCredits_ItemPercentageDivisors = [] +kCredits_ItemPercentageItemBits = [] +kCredits_ItemPercentageBeamBits = [] +kCredits_ItemPercentageDigitsTilemap = [] +kShootingStarTable = [] +kCinematicFunction_Intro_Func142_Tab0 = [] +kCinematicFunction_Intro_Func144_Tab0 = [] +kCredits_ItemPercentageJapaneseTextTilemap = [] +kShootingStarTileNumberAttributes = [] +kCinematicFunction_Intro_Func216_SourceAddresses = [] +kCinematicFunction_Intro_Func216_VramAddresses = [] +kPalettes_TitleScreen = [] +kTitleSequenceHdmaTablePtrs = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get8B(): + rom.get_data(0x8C, 0xE3E9, 0xE5E9, "uint16", kPalettes_Intro, "kPalettes_Intro", True, True, 16, -1) + rom.get_data(0x8C, 0xE5E9, 0xE7E9, "uint16", kPalettes_SpaceGunshipCeres, "kPalettes_SpaceGunshipCeres", True, True, 16, -1) + rom.get_data(0x8C, 0xE7E9, 0xE9E9, "uint16", kPalettes_PostCredits, "kPalettes_PostCredits", True, True, 16, -1) + rom.get_data(0x8C, 0xE9E9, 0xEBE9, "uint16", kPalettes_Credits, "kPalettes_Credits", True, True, 16, -1) + rom.get_data(0x8C, 0xEBE9, 0xEDE9, "uint16", kPalettes_ZebesExplosion, "kPalettes_ZebesExplosion", True, True, 16, -1) + rom.get_data(0x8C, 0xEDE9, 0xEFE9, "uint16", kPalettes_ZebesExplosionClouds, "kPalettes_ZebesExplosionClouds", True, True, 16, -1) + rom.get_data(0x8C, 0xD81B, 0xD91B, "uint16", kInitialIntro_JapaneseTextTilemap, "kInitialIntro_JapaneseTextTilemap", True, True, 32, -1) + rom.get_data(0x8B, 0xA72B, 0xA82B, "uint16", kPage1Intro_JapaneseTextRegion, "kPage1Intro_JapaneseTextRegion", True, True, 32, -1) + rom.get_data(0x8C, 0xBEC3, 0xC083, "uint16", kLevelData_MotherBrainRoomFromCutscene, "kLevelData_MotherBrainRoomFromCutscene", True, True, 16, -1) + rom.get_data(0x8C, 0xC083, 0xC383, "uint16", kLevelData_RoomWithBabyMetroidHatching, "kLevelData_RoomWithBabyMetroidHatching", True, True, 32, -1) + rom.get_data(0x8C, 0xDC9B, 0xDEDB, "uint16", kCredits_DeerForceTilemap, "kCredits_DeerForceTilemap", True, True, 32, -1) + rom.get_data(0x8C, 0xDEDB, 0xDF5B, "uint16", kCredits_1994NintendoCredits, "kCredits_1994NintendoCredits", True, True, 32, -1) + rom.get_data(0x8C, 0xEFE9, 0xF1E9, "uint16", kPalettes_EndingSuperMetroidIconGlare, "kPalettes_EndingSuperMetroidIconGlare", True, True, 16, -1) + rom.get_data(0x8B, 0xE70D, 0xE717, "uint16", kCredits_ItemPercentageRamAddresses, "kCredits_ItemPercentageRamAddresses", True, True, -1, 1) + rom.get_data(0x8B, 0xE717, 0xE721, "uint16", kCredits_ItemPercentageDivisors, "kCredits_ItemPercentageDivisors", False, True, -1, 1) + rom.get_data(0x8B, 0xE721, 0xE737, "uint16", kCredits_ItemPercentageItemBits, "kCredits_ItemPercentageItemBits", True, True, -1, 1) + rom.get_data(0x8B, 0xE737, 0xE741, "uint16", kCredits_ItemPercentageBeamBits, "kCredits_ItemPercentageBeamBits", True, True, -1, 1) + rom.get_data(0x8B, 0xE741, 0xE769, "uint16", kCredits_ItemPercentageDigitsTilemap, "kCredits_ItemPercentageDigitsTilemap", True, True, 2, 1) + rom.get_data(0x8B, 0xE9CF, 0xEB0F, "uint16", kShootingStarTable, "kShootingStarTable", True, True, 4, 1) + rom.get_data(0x8B, 0xE45A, 0xE48A, "uint16", kCinematicFunction_Intro_Func142_Tab0, "kCinematicFunction_Intro_Func142_Tab0", True, True, 4, 1) + rom.get_data(0x8B, 0xE5E7, 0xE627, "uint16", kCinematicFunction_Intro_Func144_Tab0, "kCinematicFunction_Intro_Func144_Tab0", True, True, 16, 2) + rom.get_data(0x8C, 0xDF5B, 0xDFDB, "uint16", kCredits_ItemPercentageJapaneseTextTilemap, "kCredits_ItemPercentageJapaneseTextTilemap", True, True, 32, 1) + rom.get_data(0x8B, 0xE9A7, 0xE9CF, "uint16", kShootingStarTileNumberAttributes, "kShootingStarTileNumberAttributes", True, True, 10, 1) + rom.get_data(0x8B, 0xF6B8, 0xF6D8, "uint16", kCinematicFunction_Intro_Func216_SourceAddresses, "kCinematicFunction_Intro_Func216_SourceAddresses", True, True, 8, 1) + rom.get_data(0x8B, 0xF6D8, 0xF6F8, "uint16", kCinematicFunction_Intro_Func216_VramAddresses, "kCinematicFunction_Intro_Func216_VramAddresses", True, True, 8, 1) + rom.get_data(0x8C, 0xE1E9, 0xE3E9, "uint16", kPalettes_TitleScreen, "kPalettes_TitleScreen", True, True, 16, -1) + rom.get_data(0x8C, 0xBC5D, 0xBC7D, "uint16", kTitleSequenceHdmaTablePtrs, "kTitleSequenceHdmaTablePtrs", True, True, -1, 1) + return + +get8B() \ No newline at end of file diff --git a/Port_Extraction/bank_90/extract_bank_90.py b/Port_Extraction/bank_90/extract_bank_90.py new file mode 100644 index 0000000..92b37ec --- /dev/null +++ b/Port_Extraction/bank_90/extract_bank_90.py @@ -0,0 +1,31 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kSamusFramesForUnderwaterSfx = [] +kPauseMenuMapData = [] +kPauseMenuMapTilemaps = [] +kBeamTilePtrs = [] +kBeamPalettePtrs = [] +kLeftProjTrailInstrListPtrs = [] +kRightProjTrailInstrListPtrs = [] +kFlareAnimDelays = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_90(): + rom.get_data(0x90, 0xA514, 0xA521, "uint8", kSamusFramesForUnderwaterSfx, "kSamusFramesForUnderwaterSfx", False, True, -1, 1) + rom.get_data(0x82, 0x9717, 0x9727, "uint16", kPauseMenuMapData, "kPauseMenuMapData", True, True, -1, 1) + rom.get_data(0x82, 0x964A, 0x965F, "LongPtr", kPauseMenuMapTilemaps, "kPauseMenuMapTilemaps", True, True, -1, 1) + rom.get_data(0x90, 0xC3B1, 0xC3C9, "uint16", kBeamTilePtrs, "kBeamTilePtrs", True, True, -1, 1) + rom.get_data(0x90, 0xC3C9, 0xC3E1, "uint16", kBeamPalettePtrs, "kBeamPalettePtrs", True, True, -1, 1) + rom.get_data(0x90, 0xB5BB, 0xB609, "uint16", kLeftProjTrailInstrListPtrs, "kLeftProjTrailInstrListPtrs", True, True, 13, 1) + rom.get_data(0x90, 0xB609, 0xB657, "uint16", kRightProjTrailInstrListPtrs, "kRightProjTrailInstrListPtrs", True, True, 13, 1) + rom.get_data(0x90, 0xC481, 0xC487, "uint16", kFlareAnimDelays, "kFlareAnimDelays", True, True, -1, 1) + return + +get_90() \ No newline at end of file diff --git a/Port_Extraction/bank_91/extract_bank_91.py b/Port_Extraction/bank_91/extract_bank_91.py new file mode 100644 index 0000000..43aa1bc --- /dev/null +++ b/Port_Extraction/bank_91/extract_bank_91.py @@ -0,0 +1,59 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kXrayBlockData = [] +kSamusPalette_Normal = [] +kSamusPalette_HyperBeam = [] +kSamusPalette_NonPseudoScrew = [] +kSamusPalette_PseudoScrew = [] +kSamus_VisorColors = [] +kSamus_SpeedBoostingPalettes = [] +kSamus_HyperBeamPalettes = [] +kSamusPal_ScrewAttack = [] +kSamusPal_SpeedBoost = [] +kSamusPal_SpeedBoostShine = [] +kSamusPal_Shinespark = [] +kSamusPal_CrystalFlash0to9 = [] +kSamusPal_CrystalFlash10to15 = [] +kSamusPose_Falling = [] +kSamusPose_Landing = [] +kSamusPose_RanIntoWall = [] +kSamusTurnPose_Standing = [] +kSamusTurnPose_Crouching = [] +kSamusTurnPose_Jumping = [] +kSamusTurnPose_Falling = [] +kSamusTurnPose_Moonwalk = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_91(): + rom.get_data(0x91, 0xD2D6, 0xD2FC, "XrayBlockData", kXrayBlockData, "kXrayBlockData", True, True, 1, -1) + rom.get_data(0x91, 0xD727, 0xD72D, "uint16", kSamusPalette_Normal, "kSamusPalette_Normal", True, True, -1, 1) + rom.get_data(0x91, 0xD829, 0xD83F, "uint16", kSamusPalette_HyperBeam, "kSamusPalette_HyperBeam", True, True, -1, 1) + rom.get_data(0x91, 0xD7D5, 0xD7DB, "uint16", kSamusPalette_NonPseudoScrew, "kSamusPalette_NonPseudoScrew", True, True, -1, 1) + rom.get_data(0x91, 0xD7FF, 0xD805, "uint16", kSamusPalette_PseudoScrew, "kSamusPalette_PseudoScrew", True, True, -1, 1) + rom.get_data(0x9B, 0xA3C0, 0xA3CC, "uint16", kSamus_VisorColors, "kSamus_VisorColors", True, True, 3, 1) + rom.get_data(0x91, 0xD998, 0xD99E, "uint16", kSamus_SpeedBoostingPalettes, "kSamus_SpeedBoostingPalettes", True, True, -1, 1) + rom.get_data(0x91, 0xD99E, 0xD9B2, "uint16", kSamus_HyperBeamPalettes, "kSamus_HyperBeamPalettes", True, True, -1, 1) + rom.get_data(0x91, 0xDA4A, 0xDA50, "uint16", kSamusPal_ScrewAttack, "kSamusPal_ScrewAttack", True, True, -1, 1) + rom.get_data(0x91, 0xDAA9, 0xDAAF, "uint16", kSamusPal_SpeedBoost, "kSamusPal_SpeedBoost", True, True, -1, 1) + rom.get_data(0x91, 0xDB10, 0xDB16, "uint16", kSamusPal_SpeedBoostShine, "kSamusPal_SpeedBoostShine", True, True, -1, 1) + rom.get_data(0x91, 0xDB75, 0xDB7B, "uint16", kSamusPal_Shinespark, "kSamusPal_Shinespark", True, True, -1, 1) + rom.get_data(0x91, 0xDC00, 0xDC28, "SamusCrystalFlashPalTable", kSamusPal_CrystalFlash0to9, "kSamusPal_CrystalFlash0to9", True, True, -1, 1) + rom.get_data(0x91, 0xDC28, 0xDC34, "uint16", kSamusPal_CrystalFlash10to15, "kSamusPal_CrystalFlash10to15", True, True, -1, 1) + rom.get_data(0x91, 0xE921, 0xE931, "uint16", kSamusPose_Falling, "kSamusPose_Falling", True, True, 2, -1) + rom.get_data(0x91, 0xE9F3, 0xEA07, "uint16", kSamusPose_Landing, "kSamusPose_Landing", True, True, 5, -1) + rom.get_data(0x91, 0xEB74, 0xEB88, "uint16", kSamusPose_RanIntoWall, "kSamusPose_RanIntoWall", True, True, 5, -1) + rom.get_data(0x91, 0xF9C2, 0xF9CC, "uint8", kSamusTurnPose_Standing, "kSamusTurnPose_Standing", True, True, -1, 1) + rom.get_data(0x91, 0xF9CC, 0xF9D6, "uint8", kSamusTurnPose_Crouching, "kSamusTurnPose_Crouching", True, True, -1, 1) + rom.get_data(0x91, 0xF9D6, 0xF9E0, "uint8", kSamusTurnPose_Jumping, "kSamusTurnPose_Jumping", True, True, -1, 1) + rom.get_data(0x91, 0xF9E0, 0xF9EA, "uint8", kSamusTurnPose_Falling, "kSamusTurnPose_Falling", True, True, -1, 1) + rom.get_data(0x91, 0xF9EA, 0xF9F4, "uint8", kSamusTurnPose_Moonwalk, "kSamusTurnPose_Moonwalk", True, True, -1, 1) + return + +get_91() \ No newline at end of file diff --git a/Port_Extraction/bank_91/extract_samus_pose_transitions.py b/Port_Extraction/bank_91/extract_samus_pose_transitions.py new file mode 100644 index 0000000..33f2f65 --- /dev/null +++ b/Port_Extraction/bank_91/extract_samus_pose_transitions.py @@ -0,0 +1,172 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +class PoseEntry: + def __init__(self, addr): + self.new_input = rom.get_word(addr) + self.cur_input = rom.get_word(addr+2) + self.new_pose = rom.get_word(addr+4) + +poses_text = open('poses.txt', 'r') +poses = [] + +transition_table_ptrs = [] +transitions = [[]] +transition_ptrs_found = [] + +input_values = { + 1 << 4 : "kButton_R", + 1 << 5 : "kButton_L", + 1 << 6 : "kButton_X", + 1 << 7 : "kButton_A", + 1 << 8 : "kButton_Right", + 1 << 9 : "kButton_Left", + 1 << 10 : "kButton_Down", + 1 << 11 : "kButton_Up", + 1 << 12 : "kButton_Start", + 1 << 13 : "kButton_Select", + 1 << 14 : "kButton_Y", + 1 << 15 : "kButton_B", +} + +def get_transition_table(): + rom.get_data(0x91, 0x9EE2, 0xA0DC, "uint16", transition_table_ptrs, "transition_table_ptr", True, True, -1, 1) + return + +def get_unique_transitions(): + for transition_ptr in transition_table_ptrs: + if transition_ptr.word not in transition_ptrs_found: + transition_ptrs_found.append(transition_ptr.word) + return + +def get_transitions_from_table_entries(): + index_into_transitions = 0 + data = 0 + for transition_ptr in transition_ptrs_found: + + while True: + data = rom.get_word(0x91 << 16 | transition_ptr) + if data == 0xFFFF: + transitions[index_into_transitions].append(data) + break + + new_transition = PoseEntry(0x91 << 16 | transition_ptr) + transitions[index_into_transitions].append(new_transition) + transition_ptr += 6 + + transitions.append([]) + index_into_transitions += 1 + + transitions.pop() + return + +def convert_data_into_inputs(): + index_into_transitions = 0 + index_into_inputs = 0 + for transition in transitions: + for data in transition: + if transitions[index_into_transitions][index_into_inputs] != 0xFFFF: + value = 0x10 + new_input = data.new_input + cur_input = data.cur_input + transitions[index_into_transitions][index_into_inputs].new_input = "" + transitions[index_into_transitions][index_into_inputs].cur_input = "" + + while value <= 0x8000: + if new_input & value != 0: + transitions[index_into_transitions][index_into_inputs].new_input += input_values.get(value) + "+" + if cur_input & value != 0: + transitions[index_into_transitions][index_into_inputs].cur_input += input_values.get(value) + "+" + value = value << 1 + + if len(transitions[index_into_transitions][index_into_inputs].new_input) > 0: + transitions[index_into_transitions][index_into_inputs].new_input = transitions[index_into_transitions][index_into_inputs].new_input.rstrip(transitions[index_into_transitions][index_into_inputs].new_input[-1]) + else: + transitions[index_into_transitions][index_into_inputs].new_input = 0 + + if len(transitions[index_into_transitions][index_into_inputs].cur_input) > 0: + transitions[index_into_transitions][index_into_inputs].cur_input = transitions[index_into_transitions][index_into_inputs].cur_input.rstrip(transitions[index_into_transitions][index_into_inputs].cur_input[-1]) + else: + transitions[index_into_transitions][index_into_inputs].cur_input = 0 + + transitions[index_into_transitions][index_into_inputs].new_pose = poses[transitions[index_into_transitions][index_into_inputs].new_pose] + + index_into_inputs += 1 + if len(transitions[index_into_transitions]) < index_into_inputs + 1: + index_into_transitions += 1 + index_into_inputs = 0 + + return + +def get_poses_from_text(): + for pose in poses_text: + new_pose = pose.strip() + poses.append(new_pose) + return + +def get_arrays(): + return + +def get_switch_cases(): + case_transitions = " switch (samus_pose) {\n" + index_into_transitions = 0 + transition_found_flag = False + for transition_ptr in transition_table_ptrs: + + for i in range(index_into_transitions): + if transition_ptr.word == transition_table_ptrs[i].word: + transition_found_flag = True + #length = len(("Trans_" + hex(i)[2:].zfill(2))) + index = case_transitions.find("Trans_" + hex(i)[2:].zfill(2)) + #case_transitions = case_transitions[:index + length] + "_" + (hex(index_into_transitions)[2:].zfill(2)) + case_transitions[index + length:] + case_transitions = case_transitions[:index - 8] + "\n case " + poses[index_into_transitions] + ": " + case_transitions[index - 8:] + break + + if transition_found_flag == True: + transition_found_flag = False + index_into_transitions += 1 + continue + case_transitions += " case " + poses[index_into_transitions] + ": " + transition_number = hex(index_into_transitions)[2:].zfill(2) + index_into_transitions += 1 + case_transitions += "return Trans_" + transition_number + ";\n" + + case_transitions += " }" + return case_transitions + +def get_transition_arrays(): + case_transitions = get_switch_cases() + transition_arrays = "" + index_into_transitions = 0 + indices = [i for i in range(len(case_transitions)) if case_transitions.startswith(' Trans_', i)] + for transition in transitions: + transition_arrays += " static uint16" + transition_arrays += case_transitions[indices[index_into_transitions]:indices[index_into_transitions] + 9] + transition_arrays += "[] = { // " + str(hex(0x91 << 16 | transition_ptrs_found[index_into_transitions])) + "\n" + for data in transition: + if data != 0xFFFF: + transition_arrays += " %-35s, " % str(data.new_input) + transition_arrays += "%-35s, " % str(data.cur_input) + transition_arrays += "%-35s, \n" % str(data.new_pose) + else: + transition_arrays += " " + str(hex(data)) + "\n };\n\n" + index_into_transitions += 1 + return transition_arrays + +def output_samus_pose_transition_table(): + cases = get_switch_cases() + arrays = get_transition_arrays() + output = "uint16* kPoseTransitionTable(void) {\n" + arrays + cases + "\n}" + sys.stdout.write(output) + return + +get_transition_table() +get_unique_transitions() +get_transitions_from_table_entries() +get_poses_from_text() +convert_data_into_inputs() +#get_transition_arrays() +#get_switch_cases() +output_samus_pose_transition_table() \ No newline at end of file diff --git a/Port_Extraction/bank_91/poses.txt b/Port_Extraction/bank_91/poses.txt new file mode 100644 index 0000000..a8ea51e --- /dev/null +++ b/Port_Extraction/bank_91/poses.txt @@ -0,0 +1,253 @@ +kPose_00_FaceF_Powersuit +kPose_01_FaceR_Normal +kPose_02_FaceL_Normal +kPose_03_FaceR_AimU +kPose_04_FaceL_AimU +kPose_05_FaceR_AimUR +kPose_06_FaceL_AimUL +kPose_07_FaceR_AimDR +kPose_08_FaceL_AimDL +kPose_09_MoveR_NoAim +kPose_0A_MoveL_NoAim +kPose_0B_MoveR_Gun +kPose_0C_MoveL_Gun +kPose_0D +kPose_0E +kPose_0F_MoveR_AimUR +kPose_10_MoveL_AimUL +kPose_11_MoveR_AimDR +kPose_12_MoveL_AimDL +kPose_13_FaceR_Jump_NoAim_NoMove_Gun +kPose_14_FaceL_Jump_NoAim_NoMove_Gun +kPose_15_FaceR_Jump_AimU +kPose_16_FaceL_Jump_AimU +kPose_17_FaceR_Jump_AimD +kPose_18_FaceL_Jump_AimD +kPose_19_FaceR_SpinJump +kPose_1A_FaceL_SpinJump +kPose_1B_FaceR_SpaceJump +kPose_1C_FaceL_SpaceJump +kPose_1D_FaceR_Morphball_Ground +kPose_1E_MoveR_Morphball_Ground +kPose_1F_MoveL_Morphball_Ground +kPose_20 +kPose_21 +kPose_22 +kPose_23 +kPose_24 +kPose_25_FaceR_Turn_Stand +kPose_26_FaceL_Turn_Stand +kPose_27_FaceR_Crouch +kPose_28_FaceL_Crouch +kPose_29_FaceR_Fall +kPose_2A_FaceL_Fall +kPose_2B_FaceR_Fall_AimU +kPose_2C_FaceL_Fall_AimU +kPose_2D_FaceR_Fall_AimD +kPose_2E_FaceL_Fall_AimD +kPose_2F_FaceR_Turn_Jump +kPose_30_FaceL_Turn_Jump +kPose_31_FaceR_Morphball_Air +kPose_32_FaceL_Morphball_Air +kPose_33 +kPose_34 +kPose_35_FaceR_CrouchTrans +kPose_36_FaceL_CrouchTrans +kPose_37_FaceR_MorphTrans +kPose_38_FaceL_MorphTrans +kPose_39 +kPose_3A +kPose_3B_FaceR_StandTrans +kPose_3C_FaceL_StandTrans +kPose_3D_FaceR_UnmorphTrans +kPose_3E_FaceL_UnmorphTrans +kPose_3F +kPose_40 +kPose_41_FaceL_Morphball_Ground +kPose_42 +kPose_43_FaceR_Turn_Crouch +kPose_44_FaceL_Turn_Crouch +kPose_45 +kPose_46 +kPose_47 +kPose_48 +kPose_49_FaceL_Moonwalk +kPose_4A_FaceR_Moonwalk +kPose_4B_FaceR_Jumptrans +kPose_4C_FaceL_Jumptrans +kPose_4D_FaceR_Jump_NoAim_NoMove_NoGun +kPose_4E_FaceL_Jump_NoAim_NoMove_NoGun +kPose_4F_FaceL_Dmgboost +kPose_50_FaceR_Dmgboost +kPose_51_FaceR_Jump_NoAim_MoveF +kPose_52_FaceL_Jump_NoAim_MoveF +kPose_53_FaceR_Knockback +kPose_54_FaceL_Knockback +kPose_55_FaceR_Jumptrans_AimU +kPose_56_FaceL_Jumptrans_AimU +kPose_57_FaceR_Jumptrans_AimUR +kPose_58_FaceL_Jumptrans_AimUL +kPose_59_FaceR_Jumptrans_AimDR +kPose_5A_FaceL_Jumptrans_AimDL +kPose_5B +kPose_5C +kPose_5D +kPose_5E +kPose_5F +kPose_60 +kPose_61 +kPose_62 +kPose_63 +kPose_64 +kPose_65 +kPose_66 +kPose_67_FaceR_Fall_Gun +kPose_68_FaceL_Fall_Gun +kPose_69_FaceR_Jump_AimUR +kPose_6A_FaceL_Jump_AimUL +kPose_6B_FaceR_Jump_AimDR +kPose_6C_FaceL_Jump_AimDL +kPose_6D_FaceR_Fall_AimUR +kPose_6E_FaceL_Fall_AimUL +kPose_6F_FaceR_Fall_AimDR +kPose_70_FaceL_Fall_AimDL +kPose_71_FaceR_Crouch_AimUR +kPose_72_FaceL_Crouch_AimUL +kPose_73_FaceR_Crouch_AimDR +kPose_74_FaceL_Crouch_AimDL +kPose_75_FaceL_Moonwalk_AimUL +kPose_76_FaceR_Moonwalk_AimUR +kPose_77_FaceL_Moonwalk_AimDL +kPose_78_FaceR_Moonwalk_AimDR +kPose_79_FaceR_Springball_Ground +kPose_7A_FaceL_Springball_Ground +kPose_7B_MoveR_Springball_Ground +kPose_7C_MoveL_Springball_Ground +kPose_7D_FaceR_Springball_Fall +kPose_7E_FaceL_Springball_Fall +kPose_7F_FaceR_Springball_Air +kPose_80_FaceL_Springball_Air +kPose_81_FaceR_Screwattack +kPose_82_FaceL_Screwattack +kPose_83_FaceR_Walljump +kPose_84_FaceL_Walljump +kPose_85_FaceR_Crouch_AimU +kPose_86_FaceL_Crouch_AimU +kPose_87_FaceR_Turn_Fall +kPose_88_FaceL_Turn_Fall +kPose_89_FaceR_Ranintowall +kPose_8A_FaceL_Ranintowall +kPose_8B_FaceR_Turn_Stand_AimU +kPose_8C_FaceL_Turn_Stand_AimU +kPose_8D_FaceR_Turn_Stand_AimDR +kPose_8E_FaceL_Turn_Stand_AimDL +kPose_8F_FaceR_Turn_Air_AimU +kPose_90_FaceL_Turn_Air_AimU +kPose_91_FaceR_Turn_Air_AimDDR +kPose_92_FaceL_Turn_Air_AimDDL +kPose_93_FaceR_Turn_Fall_AimU +kPose_94_FaceL_Turn_Fall_AimU +kPose_95_FaceR_Turn_Fall_AimDDR +kPose_96_FaceL_Turn_Fall_AimDDL +kPose_97_FaceR_Turn_Crouch_AimU +kPose_98_FaceL_Turn_Crouch_AimU +kPose_99_FaceR_Turn_Crouch_AimDDR +kPose_9A_FaceL_Turn_Crouch_AimDDL +kPose_9B_FaceF_VariaGravitySuit +kPose_9C_FaceR_Turn_Stand_AimUR +kPose_9D_FaceL_Turn_Stand_AimUL +kPose_9E_FaceR_Turn_Air_AimUR +kPose_9F_FaceL_Turn_Air_AimUL +kPose_A0_FaceR_Turn_Fall_AimUR +kPose_A1_FaceL_Turn_Fall_AimUL +kPose_A2_FaceR_Turn_Crouch_AimUR +kPose_A3_FaceL_Turn_Crouch_AimUL +kPose_A4_FaceR_LandJump +kPose_A5_FaceL_LandJump +kPose_A6_FaceR_LandSpinJump +kPose_A7_FaceL_LandSpinJump +kPose_A8_FaceR_Grappling +kPose_A9_FaceL_Grappling +kPose_AA_FaceR_Grappling_AimDR +kPose_AB_FaceL_Grappling_AimDL +kPose_AC +kPose_AD +kPose_AE +kPose_AF +kPose_B0 +kPose_B1 +kPose_B2_FaceR_Grapple_Air +kPose_B3_FaceL_Grapple_Air +kPose_B4_FaceR_Grappling_Crouch +kPose_B5_FaceL_Grappling_Crouch +kPose_B6_FaceR_Grappling_Crouch_AimDR +kPose_B7_FaceL_Grappling_Crouch_AimDL +kPose_B8_FaceL_GrappleWalljumpPose +kPose_B9_FaceR_GrappleWalljumpPose +kPose_BA_FaceL_Draygon_NoMove_NoAim +kPose_BB_FaceL_Draygon_NoMove_AimUL +kPose_BC_FaceL_Draygon_Fire +kPose_BD_FaceL_Draygon_NoMove_AimDL +kPose_BE_FaceL_Draygon_Move +kPose_BF_FaceR_Moonwalk_TurnjumpL +kPose_C0_FaceL_Moonwalk_TurnjumpR +kPose_C1_FaceR_Moonwalk_TurnjumpL_AimUR +kPose_C2_FaceL_Moonwalk_TurnjumpR_AimUL +kPose_C3_FaceR_Moonwalk_TurnjumpL_AimDR +kPose_C4_FaceL_Moonwalk_TurnjumpR_AimDL +kPose_C5 +kPose_C6 +kPose_C7_FaceR_ShinesparkWindup_Vert +kPose_C8_FaceL_ShinesparkWindup_Vert +kPose_C9_FaceR_Shinespark_Horiz +kPose_CA_FaceL_Shinespark_Horiz +kPose_CB_FaceR_Shinespark_Vert +kPose_CC_FaceL_Shinespark_Vert +kPose_CD_FaceR_Shinespark_Diag +kPose_CE_FaceL_Shinespark_Diag +kPose_CF_FaceR_Ranintowall_AimUR +kPose_D0_FaceL_Ranintowall_AimUL +kPose_D1_FaceR_Ranintowall_AimDR +kPose_D2_FaceL_Ranintowall_AimDL +kPose_D3_FaceR_CrystalFlash +kPose_D4_FaceL_CrystalFlash +kPose_D5_FaceR_Xray_Stand +kPose_D6_FaceL_Xray_Stand +kPose_D7_FaceR_CrystalFlashEnd +kPose_D8_FaceL_CrystalFlashEnd +kPose_D9_FaceR_Xray_Crouch +kPose_DA_FaceL_Xray_Crouch +kPose_DB +kPose_DC +kPose_DD +kPose_DE +kPose_DF +kPose_E0_FaceR_LandJump_AimU +kPose_E1_FaceL_LandJump_AimU +kPose_E2_FaceR_LandJump_AimUR +kPose_E3_FaceL_LandJump_AimUL +kPose_E4_FaceR_LandJump_AimDR +kPose_E5_FaceL_LandJump_AimDL +kPose_E6_FaceR_LandJump_Fire +kPose_E7_FaceL_LandJump_Fire +kPose_E8_FaceR_Drained_CrouchFalling +kPose_E9_FaceL_Drained_CrouchFalling +kPose_EA_FaceR_Drained_Stand +kPose_EB_FaceL_Drained_Stand +kPose_EC_FaceR_Draygon_NoMove_NoAim +kPose_ED_FaceR_Draygon_NoMove_AimUR +kPose_EE_FaceR_Draygon_Fire +kPose_EF_FaceR_Draygon_NoMove_AimDR +kPose_F0_FaceR_Draygon_Move +kPose_F1_FaceR_CrouchTrans_AimU +kPose_F2_FaceL_CrouchTrans_AimU +kPose_F3_FaceR_CrouchTrans_AimUR +kPose_F4_FaceL_CrouchTrans_AimUL +kPose_F5_FaceR_CrouchTrans_AimDR +kPose_F6_FaceL_CrouchTrans_AimDL +kPose_F7_FaceR_StandTrans_AimU +kPose_F8_FaceL_StandTrans_AimU +kPose_F9_FaceR_StandTrans_AimUR +kPose_FA_FaceL_StandTrans_AimUL +kPose_FB_FaceR_StandTrans_AimDR +kPose_FC_FaceL_StandTrans_AimDL diff --git a/Port_Extraction/bank_92/extract_bank_92.py b/Port_Extraction/bank_92/extract_bank_92.py new file mode 100644 index 0000000..9b6cca0 --- /dev/null +++ b/Port_Extraction/bank_92/extract_bank_92.py @@ -0,0 +1,21 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kSamus_AnimationDefinitionPtrs = [] +kSamus_TileDefs_TopHalf = [] +kSamus_TileDefs_BottomHalf = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_92(): + rom.get_data(0x92, 0xD94E, 0xDB48, "uint16", kSamus_AnimationDefinitionPtrs, "kSamus_AnimationDefinitionPtrs", True, True, 16, 1) + rom.get_data(0x92, 0xD91E, 0xD938, "uint16", kSamus_TileDefs_TopHalf, "kSamus_TileDefs_TopHalf", True, True, -1, 1) + rom.get_data(0x92, 0xD938, 0xD94E, "uint16", kSamus_TileDefs_BottomHalf, "kSamus_TileDefs_BottomHalf", True, True, -1, 1) + return + +get_92() \ No newline at end of file diff --git a/Port_Extraction/bank_93/extract_bank_93.py b/Port_Extraction/bank_93/extract_bank_93.py new file mode 100644 index 0000000..4c6c356 --- /dev/null +++ b/Port_Extraction/bank_93/extract_bank_93.py @@ -0,0 +1,35 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kProjectileData_UnchargedBeams = [] +kProjectileData_ChargedBeams = [] +kProjectileData_NonBeams = [] +kShinesparkEchoSpazer_ProjectileData = [] +kRunInstrForSuperMissile = [] +kProjInstrList_SuperMissileExplosion = [] +kProjInstrList_MissileExplosion = [] +kProjInstrList_BeamExplosion = [] +kProjInstrList_BombExplosion = [] +kProjectileData_SBA = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_93(): + rom.get_data(0x93, 0x83C1, 0x83D9, "uint16", kProjectileData_UnchargedBeams, "kProjectileData_UnchargedBeams", True, True, -1, 1) + rom.get_data(0x93, 0x83D9, 0x83F1, "uint16", kProjectileData_ChargedBeams, "kProjectileData_ChargedBeams", True, True, -1, 1) + rom.get_data(0x93, 0x83F1, 0x8403, "uint16", kProjectileData_NonBeams, "kProjectileData_NonBeams", True, True, -1, 1) + rom.get_data(0x93, 0x8403, 0x8413, "uint16", kShinesparkEchoSpazer_ProjectileData, "kShinesparkEchoSpazer_ProjectileData", True, True, -1, 1) + rom.get_data(0x93, 0x842B, 0x8431, "uint16", kRunInstrForSuperMissile, "kRunInstrForSuperMissile", True, True, -1, 1) + rom.get_data(0x93, 0x8691, 0x8695, "ProjectileDamagesAndInstrPtr", kProjInstrList_SuperMissileExplosion, "kProjInstrList_SuperMissileExplosion", True, False, -1, -1) + rom.get_data(0x93, 0x867D, 0x8681, "ProjectileDamagesAndInstrPtr", kProjInstrList_MissileExplosion, "kProjInstrList_MissileExplosion", True, False, -1, -1) + rom.get_data(0x93, 0x8679, 0x867D, "ProjectileDamagesAndInstrPtr", kProjInstrList_BeamExplosion, "kProjInstrList_BeamExplosion", True, False, -1, -1) + rom.get_data(0x93, 0x8681, 0x8685, "ProjectileDamagesAndInstrPtr", kProjInstrList_BombExplosion, "kProjInstrList_BombExplosion", True, False, -1, 1) + rom.get_data(0x93, 0x8413, 0x842B, "uint16", kProjectileData_SBA, "kProjectileData_SBA", True, True, -1, 1) + return + +get_93() \ No newline at end of file diff --git a/Port_Extraction/bank_94/extract_bank_94.py b/Port_Extraction/bank_94/extract_bank_94.py new file mode 100644 index 0000000..41c0b79 --- /dev/null +++ b/Port_Extraction/bank_94/extract_bank_94.py @@ -0,0 +1,25 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kSpecialAirPtrs = [] +kSpecialBlockPtrs = [] +kPlmHeaderDefPtrs = [] +kBombablePlmTable = [] +kBlockShotBombedReactionShootablePlm = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_94(): + rom.get_data(0x94, 0x92D9, 0x92E9, "uint16", kSpecialAirPtrs, "kSpecialAirPtrs", True, True, -1, 1) + rom.get_data(0x94, 0x92E9, 0x92F9, "uint16", kSpecialBlockPtrs, "kSpecialBlockPtrs", True, True, -1, 1) + rom.get_data(0x94, 0x9139, 0x91D9, "uint16", kPlmHeaderDefPtrs, "kPlmHeaderDefPtrs", True, True, 16, 1) + rom.get_data(0x94, 0x936B, 0x938B, "uint16", kBombablePlmTable, "kBombablePlmTable", True, True, -1, 1) + rom.get_data(0x94, 0x9EA6, 0x9F46, "uint16", kBlockShotBombedReactionShootablePlm, "kBlockShotBombedReactionShootablePlm", True, True, 16, 1) + return + +get_94() \ No newline at end of file diff --git a/Port_Extraction/bank_9B/extract_bank_9B.py b/Port_Extraction/bank_9B/extract_bank_9B.py new file mode 100644 index 0000000..a4dacd6 --- /dev/null +++ b/Port_Extraction/bank_9B/extract_bank_9B.py @@ -0,0 +1,81 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kUnchargedBeamTrailOffsets = [] +kChargedBeamTrailOffsets = [] +kSpazerSbaTrailOffsets = [] +kDeathSequencePals_SuitOffset_1 = [] +kDeathSequencePalette_ExplosionTabs = [] +kDeathSequencePals_SuitOffset_2 = [] +kDeathSequencePals_Suitless = [] +kGrappleBlockDefaultConnectionPtrs = [] +kGrappleBlockVerticalMovementConnectionPtrs = [] +kGrappleBlockCrouchConnectionPtrs = [] +kGrappleBeam_SpecialAngles = [] +kGrappleBeam_SwingingData = [] +kGrappleBeam_SwingingData2 = [] +kGrappleBeam_SwingingData3 = [] +kGrappleBeam_OriginX_NoRun = [] +kGrappleBeam_OriginY_NoRun = [] +kGrappleBeam_0x0d1a_offs_NoRun = [] +kGrappleBeam_0x0d1c_offs_NoRun = [] +kGrappleBeam_OriginX_Run = [] +kGrappleBeam_OriginY_Run = [] +kGrappleBeam_0x0d1a_offs_Run = [] +kGrappleBeam_0x0d1c_offs_Run = [] +kGrappleBeamFlareTileEndPtr = [] +kGrappleBeamFlareTileBeginPtr = [] +kGrappleBeamTilePtrs = [] +kFlareAnimDelays_Main = [] +kFlareLeftSpritemapOffsets = [] +kFlareRightSpritemapOffsets = [] +kGrappleToStandingSamusPoses = [] +kGrappleToCrouchingSamusPoses = [] +kGrappleBeam_Ext_Xvel = [] +kGrappleBeam_Ext_Yvel = [] +kGrappleBeam_Init_EndAngle = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_9B(): + rom.get_data(0x9B, 0xA4B3, 0xA4CB, "uint16", kUnchargedBeamTrailOffsets, "kUnchargedBeamTrailOffsets", True, True, -1 , 1) + rom.get_data(0x9B, 0xA4CB, 0xA4E3, "uint16", kChargedBeamTrailOffsets, "kChargedBeamTrailOffsets", True, True, -1, 1) + rom.get_data(0x9B, 0xA4E3, 0xA4F7, "uint16", kSpazerSbaTrailOffsets, "kSpazerSbaTrailOffsets", True, True, -1, 1) + rom.get_data(0x9B, 0xB5C8, 0xB5CE, "uint16", kDeathSequencePals_SuitOffset_1, "kDeathSequencePals_SuitOffset_1", True, True, -1, 1) + rom.get_data(0x9B, 0xB823, 0xB835, "uint8", kDeathSequencePalette_ExplosionTabs, "kDeathSequencePalette_ExplosionTabs", False, True, 2, -1) + rom.get_data(0x9B, 0xB6D2, 0xB6D8, "uint16", kDeathSequencePals_SuitOffset_2, "kDeathSequencePals_SuitOffset_2", True, True, -1, 1) + rom.get_data(0x9B, 0xB80F, 0xB823, "uint16", kDeathSequencePals_Suitless, "kDeathSequencePals_Suitless", True, True, -1, 1) + rom.get_data(0x9B, 0xC3C6, 0xC3EE, "uint16", kGrappleBlockDefaultConnectionPtrs, "kGrappleBlockDefaultConnectionPtrs", True, True, 2, 1) + rom.get_data(0x9B, 0xC3EE, 0xC416, "uint16", kGrappleBlockVerticalMovementConnectionPtrs, "kGrappleBlockVerticalMovementConnectionPtrs", True, True, 2, 1) + rom.get_data(0x9B, 0xC416, 0xC43E, "uint16", kGrappleBlockCrouchConnectionPtrs, "kGrappleBlockCrouchConnectionPtrs", True, True, 2, 1) + rom.get_data(0x9B, 0xC43E, 0xC48E, "GrappleBeamSpecialAngles", kGrappleBeam_SpecialAngles, "kGrappleBeam_SpecialAngles", True, True, 1, -1) + rom.get_data(0x9B, 0xC1C2, 0xC2C2, "uint8", kGrappleBeam_SwingingData, "kGrappleBeam_SwingingData", False, True, 16, 1) + rom.get_data(0x9B, 0xC2C2, 0xC302, "uint8", kGrappleBeam_SwingingData2, "kGrappleBeam_SwingingData2", True, True, 32, 2) + rom.get_data(0x9B, 0xC302, 0xC342, "uint8", kGrappleBeam_SwingingData3, "kGrappleBeam_SwingingData3", True, True, 32, 2) + rom.get_data(0x9B, 0xC122, 0xC136, "uint16", kGrappleBeam_OriginX_NoRun, "kGrappleBeam_OriginX_NoRun", True, True, -1, 1) + rom.get_data(0x9B, 0xC136, 0xC14A, "uint16", kGrappleBeam_OriginY_NoRun, "kGrappleBeam_OriginY_NoRun", True, True, -1, 1) + rom.get_data(0x9B, 0xC14A, 0xC15E, "uint16", kGrappleBeam_0x0d1a_offs_NoRun, "kGrappleBeam_0x0d1a_offs_NoRun", True, True, -1, 1) + rom.get_data(0x9B, 0xC15E, 0xC172, "uint16", kGrappleBeam_0x0d1c_offs_NoRun, "kGrappleBeam_0x0d1c_offs_NoRun", True, True, -1, 1) + rom.get_data(0x9B, 0xC172, 0xC186, "uint16", kGrappleBeam_OriginX_Run, "kGrappleBeam_OriginX_Run", True, True, -1, 1) + rom.get_data(0x9B, 0xC186, 0xC19A, "uint16", kGrappleBeam_OriginY_Run, "kGrappleBeam_OriginY_Run", True, True, -1, 1) + rom.get_data(0x9B, 0xC19A, 0xC1AE, "uint16", kGrappleBeam_0x0d1a_offs_Run, "kGrappleBeam_0x0d1a_offs_Run", True, True, -1, 1) + rom.get_data(0x9B, 0xC1AE, 0xC1C2, "uint16", kGrappleBeam_0x0d1c_offs_Run, "kGrappleBeam_0x0d1c_offs_Run", True, True, -1, 1) + rom.get_data(0x9B, 0xC344, 0xC346, "uint16", kGrappleBeamFlareTileEndPtr, "kGrappleBeamFlareTileEndPtr", True, False, -1, -1) + rom.get_data(0x9B, 0xC342, 0xC344, "uint16", kGrappleBeamFlareTileBeginPtr, "kGrappleBeamFlareTileBeginPtr", True, False, -1, -1) + rom.get_data(0x9B, 0xC346, 0xC3C6, "uint16", kGrappleBeamTilePtrs, "kGrappleBeamTilePtrs", True, True, 16, 1) + rom.get_data(0x90, 0xC487, 0xC4A7, "uint8", kFlareAnimDelays_Main, "kFlareAnimDelays_Main", False, True, 16, 1) + rom.get_data(0x93, 0xA22B, 0xA231, "uint16", kFlareLeftSpritemapOffsets, "kFlareLeftSpritemapOffsets", False, True, -1, -1) + rom.get_data(0x93, 0xA225, 0xA22B, "uint16", kFlareRightSpritemapOffsets, "kFlareRightSpritemapOffsets", False, True, -1, -1) + rom.get_data(0x9C, 0xC9BA, 0xC9C4, "uint8", kGrappleToStandingSamusPoses, "kGrappleToStandingSamusPoses", True, True, -1, 1) + rom.get_data(0x9B, 0xC9C4, 0xC9CE, "uint8", kGrappleToCrouchingSamusPoses, "kGrappleToCrouchingSamusPoses", True, True, -1, 1) + rom.get_data(0x9B, 0xC0DB, 0xC0EF, "uint16", kGrappleBeam_Ext_Xvel, "kGrappleBeam_Ext_Xvel", True, True, -1, 1) + rom.get_data(0x9B, 0xC0EF, 0xC103, "uint16", kGrappleBeam_Ext_Yvel, "kGrappleBeam_Ext_Yvel", True, True, -1, 1) + rom.get_data(0x9B, 0xC104, 0xC118, "uint16", kGrappleBeam_Init_EndAngle, "kGrappleBeam_Init_EndAngle", True, True, -1, 1) + return + +get_9B() \ No newline at end of file diff --git a/Port_Extraction/bank_A0/extract_bank_A0.py b/Port_Extraction/bank_A0/extract_bank_A0.py new file mode 100644 index 0000000..b7de455 --- /dev/null +++ b/Port_Extraction/bank_A0/extract_bank_A0.py @@ -0,0 +1,29 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kEnemyLayerToQueuePtr = [] +kStandardSpriteTiles = [] +kSine8bit = [] +kEquationForQuarterCircle = [] +kEnemyDestroySpikeBtsOffset = [] +kEnemyXYSlopeOffsetMultiplicationIndices = [] +kAlignYPos_Tab0 = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_A0(): + rom.get_data(0xA0, 0xB133, 0xB143, "uint16", kEnemyLayerToQueuePtr, "kEnemyLayerToQueuePtr", True, True, -1, 1) + rom.get_data(0x9A, 0xD200, 0xF200, "uint16", kStandardSpriteTiles, "kStandardSpriteTiles", True, True, 16, 1) + rom.get_data(0xA0, 0xB143, 0xB5C3, "uint8", kSine8bit, "kSine8bit", True, True, 16, 1) + rom.get_data(0xA0, 0xB7EE, 0xB8EE, "uint16", kEquationForQuarterCircle, "kEquationForQuarterCircle", True, True, 16, 1) + rom.get_data(0xA0, 0xC2DA, 0xC2FA, "uint16", kEnemyDestroySpikeBtsOffset, "kEnemyDestroySpikeBtsOffset", True, True, -1, 1) + rom.get_data(0xA0, 0xC49F, 0xC51F, "uint16", kEnemyXYSlopeOffsetMultiplicationIndices, "kEnemyXYSlopeOffsetMultiplicationIndices", True, True, 16, 2) + rom.get_data(0x94, 0x8B2B, 0x8D2B, "uint8", kAlignYPos_Tab0, "kAlignYPos_Tab0", False, True, 16, 1) + return + +get_A0() \ No newline at end of file diff --git a/Port_Extraction/bank_A2/extract_bank_A2.py b/Port_Extraction/bank_A2/extract_bank_A2.py new file mode 100644 index 0000000..4c0a422 --- /dev/null +++ b/Port_Extraction/bank_A2/extract_bank_A2.py @@ -0,0 +1,82 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kEnemyInit_BouncingGoofball_Tab0 = [] +kEnemyInit_BouncingGoofball_Tab1 = [] +kBouncingGoofball_Tab0 = [] +kMaridiaBeybladeTurtle_Tab0 = [] +kThinHoppingBlobs_HopTable = [] +kEnemyInit_SpikeShootingPlant_XRadiusTravel = [] +kEnemyInit_SpikeShootingPlant_FuncPtrs = [] +kEnemyInit_MaridiaSpikeyShell_XDistanceRanges = [] +kEnemyInit_MaridiaSpikeyShell_UndergroundTimers = [] +kGunshipTop_HoverValues = [] +kGunshipTop_YVelocitiesBrakeData = [] +kGunshipTop_DustCloudTilesSourceAddresses = [] +kGunshipTop_DustCloudTilesDestinationAddresses = [] +kLavaquakeRocks_Tab0 = [] +kLavaquakeRocks_Tab1 = [] +kLavaquakeRocks_Tab2 = [] +kRinka_MotherBrainRoomSpawnTable = [] +kRio_Constant0 = [] +kRio_Constant1 = [] +kNorfairLavajumpingEnemy_Tab0 = [] +kNorfairRio_Tab0 = [] +kNorfairRio_Constant0 = [] +kLowerNorfairRio_Constant0 = [] +kLowerNorfairRio_Constant1 = [] +kMaridiaLargeSnail_InstrListPtrs = [] +kHirisingSlowFalling_Ptrs0 = [] +kHirisingSlowFalling_Ptrs1 = [] +kLavaSeahorse_InstrListPtrs = [] +kEnemyInit_TimedShutter_YPositionIndices = [] +kEnemyInit_TimedShutter_FuncPtrs = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_A2(): + rom.get_data(0xA2, 0x86DF, 0x86EF, "uint16", kEnemyInit_BouncingGoofball_Tab0, "kEnemyInit_BouncingGoofball_Tab0", False, True, -1, 1) + rom.get_data(0xA2, 0x86EF, 0x8701, "uint16", kEnemyInit_BouncingGoofball_Tab1, "kEnemyInit_BouncingGoofball_Tab1", True, True, -1, 1) + rom.get_data(0xA2, 0x8701, 0x8718, "uint8", kBouncingGoofball_Tab0, "kBouncingGoofball_Tab0", False, True, -1, 1) + rom.get_data(0xA2, 0x8D56, 0x8D5E, "uint16", kMaridiaBeybladeTurtle_Tab0, "kMaridiaBeybladeTurtle_Tab0", True, True, -1, 1) + rom.get_data(0xA2, 0x9A07, 0x9A3F, "uint16", kThinHoppingBlobs_HopTable, "kThinHoppingBlobs_HopTable", True, True, 4, 1) + rom.get_data(0xA2, 0x9F36, 0x9F42, "uint16", kEnemyInit_SpikeShootingPlant_XRadiusTravel, "kEnemyInit_SpikeShootingPlant_XRadiusTravel", False, True, -1, 1) + rom.get_data(0xA2, 0x9F42, 0x9F48, "uint16", kEnemyInit_SpikeShootingPlant_FuncPtrs, "kEnemyInit_SpikeShootingPlant_FuncPtrs", True, True, -1, 1) + rom.get_data(0xA2, 0xA3DD, 0xA3ED, "uint16", kEnemyInit_MaridiaSpikeyShell_XDistanceRanges, "kEnemyInit_MaridiaSpikeyShell_XDistanceRanges", False, True, -1, 1) + rom.get_data(0xA2, 0xA3ED, 0xA3F9, "uint16", kEnemyInit_MaridiaSpikeyShell_UndergroundTimers, "kEnemyInit_MaridiaSpikeyShell_UndergroundTimers", False, True, -1, 1) + rom.get_data(0xA2, 0xA7CF, 0xA7D7, "uint8", kGunshipTop_HoverValues, "kGunshipTop_HoverValues", True, True, 2, 1) + rom.get_data(0xA2, 0xA622, 0xA644, "uint16", kGunshipTop_YVelocitiesBrakeData, "kGunshipTop_YVelocitiesBrakeData", True, True, 6, 1) + rom.get_data(0xA2, 0xAC07, 0xAC11, "uint16", kGunshipTop_DustCloudTilesSourceAddresses, "kGunshipTop_DustCloudTilesSourceAddresses", True, True, -1, 1) + rom.get_data(0xA2, 0xAC11, 0xAC1B, "uint16", kGunshipTop_DustCloudTilesDestinationAddresses, "kGunshipTop_DustCloudTilesDestinationAddresses", True, True, -1, 1) + rom.get_data(0xA2, 0xB520, 0xB530, "uint16", kLavaquakeRocks_Tab0, "kLavaquakeRocks_Tab0", True, True, -1, 1) + rom.get_data(0xA2, 0xB530, 0xB550, "uint16", kLavaquakeRocks_Tab1, "kLavaquakeRocks_Tab1", True, True, 8, 1) + rom.get_data(0xA2, 0xB550, 0xB570, "uint16", kLavaquakeRocks_Tab2, "kLavaquakeRocks_Tab2", True, True, 8, 1) + rom.get_data(0xA2, 0xB75B, 0xB79D, "uint16", kRinka_MotherBrainRoomSpawnTable, "kRinka_MotherBrainRoomSpawnTable", True, True, 3, 1) + rom.get_data(0xA2, 0xBBBB, 0xBBBD, "uint16", kRio_Constant0, "kRio_Constant0", True, False, -1, -1) + rom.get_data(0xA2, 0xBBBF, 0xBBC1, "uint16", kRio_Constant1, "kRio_Constant1", True, False, -1, -1) + rom.get_data(0xA2, 0xBE86, 0xBE8E, "uint16", kNorfairLavajumpingEnemy_Tab0, "kNorfairLavajumpingEnemy_Tab0", True, True, -1, 1) + rom.get_data(0xA2, 0xC1C1, 0xC1C5, "uint16", kNorfairRio_Tab0, "kNorfairRio_Tab0", True, True, -1, 1) + rom.get_data(0xA2, 0xC1C5, 0xC1C7, "uint16", kNorfairRio_Constant0, "kNorfairRio_Constant0", True, False, -1, -1) + rom.get_data(0xA2, 0xC6CA, 0xC6CC, "uint16", kLowerNorfairRio_Constant0, "kLowerNorfairRio_Constant0", True, False, -1, -1) + rom.get_data(0xA2, 0xC6CE, 0xC6D0, "uint16", kLowerNorfairRio_Constant1, "kLowerNorfairRio_Constant1", True, False, -1, -1) + rom.get_data(0xA2, 0xCB77, 0xCB87, "uint16", kMaridiaLargeSnail_InstrListPtrs, "kMaridiaLargeSnail_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA2, 0xDF5E, 0xDF6A, "uint16", kHirisingSlowFalling_Ptrs0, "kHirisingSlowFalling_Ptrs0", True, True, -1, 1) + rom.get_data(0xA2, 0xDF6A, 0xDF76, "uint16", kHirisingSlowFalling_Ptrs1, "kHirisingSlowFalling_Ptrs1", True, True, -1, 1) + rom.get_data(0xA2, 0xE5EF, 0xE5FB, "uint16", kLavaSeahorse_InstrListPtrs, "kLavaSeahorse_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA2, 0xEA56, 0xEAB6, "uint16", kEnemyInit_TimedShutter_YPositionIndices, "kEnemyInit_TimedShutter_YPositionIndices", True, True, 16, 2) + rom.get_data(0xA2, 0xEA4E, 0xEA56, "uint16", kEnemyInit_TimedShutter_FuncPtrs, "kEnemyInit_TimedShutter_FuncPtrs", True, True, -1, 1) + return + +#define kMaridiaBeybladeTurtle_Tab0 (*(uint16*)RomFixedPtr(0xa28d56)) +#define kMaridiaBeybladeTurtle_Tab1 (*(uint16*)RomFixedPtr(0xa28d58)) +#define kThinHoppingBlobs_JumpHeightIndices (*(uint16*)RomFixedPtr(0xa29a07)) +#define kThinHoppingBlobs_XSpeedIndices (*(uint16*)RomFixedPtr(0xa29a09)) +#define kThinHoppingBlobs_YSpeedIndices (*(uint16*)RomFixedPtr(0xa29a0b)) +#define kThinHoppingBlobs_AirborneFuncPtrs (*(uint16*)RomFixedPtr(0xa29a0d)) + +get_A2() \ No newline at end of file diff --git a/Port_Extraction/bank_A3/extract_bank_A3.py b/Port_Extraction/bank_A3/extract_bank_A3.py new file mode 100644 index 0000000..c241378 --- /dev/null +++ b/Port_Extraction/bank_A3/extract_bank_A3.py @@ -0,0 +1,119 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kWaver_InstrListPtrs = [] +kMetalee_InstrListPtrs = [] +kFireFlea_Tab0 = [] +kElevator_ControllerInputs = [] +kEnemyInit_Crab_InstrListPtrs = [] +kEnemyInit_Slug_InstrListPtrs = [] +kRoach_InstrListPtrs = [] +kRoach_FuncPtrs = [] +kSidehopper_InstrListPtrs0 = [] +kSidehopper_InstrListPtrs1 = [] +kSidehopper_InstrListPtrs2 = [] +kSidehopper_InstrListPtrs3 = [] +kSidehopper_FuncPtrs = [] +kSidehopper_Tab0 = [] +kSidehopper_Tab1 = [] +kSidehopper_Tab2 = [] +kSidehopper_Tab3 = [] +kSidehopper_Tab4 = [] +kSidehopper_Tab5 = [] +kMaridiaRefillCandy_XPositionIndices = [] +kMaridiaRefillCandy_InstrListPtrs = [] +kEnemyInit_NorfairSlowFireball_InstrListPtrs = [] +kEnemyInit_Bang_Tab0 = [] +kBang_ShotDirectionIndices = [] +kBang_ShotSoundIndices = [] +kEnemyInit_Bang_Tab1 = [] +kBang_InstrListPtrs = [] +kSkree_InstrListPtrs = [] +kMaridiaSnail_Tab0 = [] +kMaridiaSnail_Tab1 = [] +kMaridiaSnail_Tab2 = [] +kMaridiaSnail_Tab3 = [] +kMaridiaSnail_FuncPtrs = [] +kMaridiaSnail_InstrListPtrs0 = [] +kMaridiaSnail_InstrListPtrs1 = [] +kMaridiaSnail_InstrListPtrs2 = [] +kMaridiaSnail_Tab4 = [] +kMaridiaSnail_InstrListPtrs3 = [] +kReflec_GlowColorsIndices = [] +kReflec_InstrListPtrs0 = [] +kReflec_ShootDirectionsIndices = [] +kReflec_InstrListPtrs1 = [] +kEnemyInit_WreckedShipOrangeZoomer_InstrListPtrs = [] +kCommonZoomer_SpeedIndices = [] +kCommonZoomer_InstrListPtrs0 = [] +kCommonZoomer_InstrListPtrs1 = [] +kCommonZoomer_InstrListPtrs2 = [] +kCommonZoomer_InstrListPtrs3 = [] +kCommonZoomer_InstrListPtrs4 = [] +kCommonZoomer_Tab0 = [] +kMetroid_CrySoundsIndices = [] +kMetroid_SpeedIndices = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_A3(): + rom.get_data(0xA3, 0x86DB, 0x86E3, "uint16", kWaver_InstrListPtrs, "kWaver_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA3, 0x894E, 0x8956, "uint16", kMetalee_InstrListPtrs, "kMetalee_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA3, 0x8D1D, 0x8D2D, "uint16", kFireFlea_Tab0, "kFireFlea_Tab0", False, True, -1, 1) + rom.get_data(0xA3, 0x94E2, 0x94E6, "uint16", kElevator_ControllerInputs, "kElevator_ControllerInputs", True, True, -1, 1) + rom.get_data(0xA3, 0x96DB, 0x96E3, "uint16", kEnemyInit_Crab_InstrListPtrs, "kEnemyInit_Crab_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA3, 0x992B, 0x993B, "uint16", kEnemyInit_Slug_InstrListPtrs, "kEnemyInit_Slug_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA3, 0xA111, 0xA121, "uint16", kRoach_InstrListPtrs, "kRoach_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA3, 0xA121, 0xA12F, "uint16", kRoach_FuncPtrs, "kRoach_FuncPtrs", True, True, -1, 1) + rom.get_data(0xA3, 0xAAC2, 0xAACA, "uint16", kSidehopper_InstrListPtrs0, "kSidehopper_InstrListPtrs0", True, True, -1, 1) + rom.get_data(0xA3, 0xAACA, 0xAAD2, "uint16", kSidehopper_InstrListPtrs1, "kSidehopper_InstrListPtrs1", True, True, -1, 1) + rom.get_data(0xA3, 0xAAD2, 0xAADA, "uint16", kSidehopper_InstrListPtrs2, "kSidehopper_InstrListPtrs2", True, True, -1, 1) + rom.get_data(0xA3, 0xAADA, 0xAAE2, "uint16", kSidehopper_InstrListPtrs3, "kSidehopper_InstrListPtrs3", True, True, -1, 1) + rom.get_data(0xA3, 0xAAE2, 0xAAE6, "uint16", kSidehopper_FuncPtrs, "kSidehopper_FuncPtrs", True, True, -1, 1) + rom.get_data(0xA3, 0xAAE6, 0xAAEA, "uint16", kSidehopper_Tab0, "kSidehopper_Tab0", False, True, -1, 1) + rom.get_data(0xA3, 0xAAEA, 0xAAEE, "uint16", kSidehopper_Tab1, "kSidehopper_Tab1", False, True, -1, 1) + rom.get_data(0xA3, 0xAAEE, 0xAAF2, "uint16", kSidehopper_Tab2, "kSidehopper_Tab2", True, True, -1, 1) + rom.get_data(0xA3, 0xAAF2, 0xAAF6, "uint16", kSidehopper_Tab3, "kSidehopper_Tab3", False, True, -1, 1) + rom.get_data(0xA3, 0xAAF6, 0xAAFA, "uint16", kSidehopper_Tab4, "kSidehopper_Tab4", False, True, -1, 1) + rom.get_data(0xA3, 0xAAFA, 0xAAFE, "uint16", kSidehopper_Tab5, "kSidehopper_Tab5", True, True, -1, 1) + rom.get_data(0xA3, 0xB415, 0xB429, "uint16", kMaridiaRefillCandy_XPositionIndices, "kMaridiaRefillCandy_XPositionIndices", True, True, -1, 2) + rom.get_data(0xA3, 0xB40D, 0xB415, "uint16", kMaridiaRefillCandy_InstrListPtrs, "kMaridiaRefillCandy_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA3, 0xB667, 0xB66F, "uint16", kEnemyInit_NorfairSlowFireball_InstrListPtrs, "kEnemyInit_NorfairSlowFireball_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA3, 0xBA84, 0xBA94, "uint16", kEnemyInit_Bang_Tab0, "kEnemyInit_Bang_Tab0", True, True, -1, 1) + rom.get_data(0xA3, 0xBA94, 0xBAA8, "uint16", kBang_ShotDirectionIndices, "kBang_ShotDirectionIndices", True, True, -1, 1) + rom.get_data(0xA3, 0xBC4A, 0xBC6A, "uint16", kBang_ShotSoundIndices, "kBang_ShotSoundIndices", False, True, -1, 1) + rom.get_data(0xA3, 0xBC6A, 0xBC9E, "uint16", kEnemyInit_Bang_Tab1, "kEnemyInit_Bang_Tab1", False, True, 13, 1) + rom.get_data(0xA3, 0xB722, 0xB75E, "uint16", kBang_InstrListPtrs, "kBang_InstrListPtrs", True, True, 5, 1) + rom.get_data(0xA3, 0xC69C, 0xC6A4, "uint16", kSkree_InstrListPtrs, "kSkree_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA3, 0xCD42, 0xCD82, "MaridiaSnailData2", kMaridiaSnail_Tab0, "kMaridiaSnail_Tab0", True, True, 1, 1) + rom.get_data(0xA3, 0xCD82, 0xCDC2, "uint16", kMaridiaSnail_Tab1, "kMaridiaSnail_Tab1", True, True, 4, 1) + rom.get_data(0xA3, 0xCDC2, 0xCDD2, "uint16", kMaridiaSnail_Tab2, "kMaridiaSnail_Tab2", False, True, -1, 1) + rom.get_data(0xA3, 0xCCA2, 0xCCE2, "uint16", kMaridiaSnail_Tab3, "kMaridiaSnail_Tab3", True, True, 16, 1) + rom.get_data(0xA3, 0xCDD2, 0xCDE2, "uint16", kMaridiaSnail_FuncPtrs, "kMaridiaSnail_FuncPtrs", True, True, -1, 1) + rom.get_data(0xA3, 0xD1AB, 0xD1B3, "uint16", kMaridiaSnail_InstrListPtrs0, "kMaridiaSnail_InstrListPtrs0", True, True, -1, 2) + rom.get_data(0xA3, 0xD30D, 0xD315, "uint16", kMaridiaSnail_InstrListPtrs1, "kMaridiaSnail_InstrListPtrs1", True, True, -1, 2) + rom.get_data(0xA3, 0xD50F, 0xD517, "uint16", kMaridiaSnail_InstrListPtrs2, "kMaridiaSnail_InstrListPtrs2", True, True, -1, 2) + rom.get_data(0xA3, 0xD517, 0xD557, "uint16", kMaridiaSnail_Tab4, "kMaridiaSnail_Tab4", True, True, 6, 2) + rom.get_data(0xA3, 0xD5A4, 0xD5AC, "uint16", kMaridiaSnail_InstrListPtrs3, "kMaridiaSnail_InstrListPtrs3", True, True, -1, 2) + rom.get_data(0xA3, 0xDABC, 0xDB0C, "uint16", kReflec_GlowColorsIndices, "kReflec_GlowColorsIndices", True, True, 4, 1) + rom.get_data(0xA3, 0xDC0B, 0xDC1B, "uint16", kReflec_InstrListPtrs0, "kReflec_InstrListPtrs0", True, True, -1, 1) + rom.get_data(0xA3, 0xDCAE, 0xDD2E, "uint16", kReflec_ShootDirectionsIndices, "kReflec_ShootDirectionsIndices", True, True, 16, 1) + rom.get_data(0xA3, 0xDCA6, 0xDCAE, "uint16", kReflec_InstrListPtrs1, "kReflec_InstrListPtrs1", True, True, -1, 1) + rom.get_data(0xA3, 0xE03B, 0xE043, "uint16", kEnemyInit_WreckedShipOrangeZoomer_InstrListPtrs, "kEnemyInit_WreckedShipOrangeZoomer_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA3, 0xE5F0, 0xE630, "uint16", kCommonZoomer_SpeedIndices, "kCommonZoomer_SpeedIndices", True, True, 16, 1) + rom.get_data(0xA3, 0xE2CC, 0xE2D4, "uint16", kCommonZoomer_InstrListPtrs0, "kCommonZoomer_InstrListPtrs0", True, True, -1, 1) + rom.get_data(0xA3, 0xE630, 0xE63C, "uint16", kCommonZoomer_InstrListPtrs1, "kCommonZoomer_InstrListPtrs1", True, True, -1, 1) + rom.get_data(0xA3, 0xE63C, 0xE648, "uint16", kCommonZoomer_InstrListPtrs2, "kCommonZoomer_InstrListPtrs2", True, True, -1, 1) + rom.get_data(0xA3, 0xE648, 0xE654, "uint16", kCommonZoomer_InstrListPtrs3, "kCommonZoomer_InstrListPtrs3", True, True, -1, 1) + rom.get_data(0xA3, 0xE654, 0xE660, "uint16", kCommonZoomer_InstrListPtrs4, "kCommonZoomer_InstrListPtrs4", True, True, -1, 1) + rom.get_data(0xA3, 0xE931, 0xE9AF, "uint16", kCommonZoomer_Tab0, "kCommonZoomer_Tab0", True, True, 16, 1) + rom.get_data(0xA3, 0xEAD6, 0xEAE6, "uint16", kMetroid_CrySoundsIndices, "kMetroid_CrySoundsIndices", False, True, -1, 1) + rom.get_data(0xA3, 0xEA3F, 0xEA47, "uint16", kMetroid_SpeedIndices, "kMetroid_SpeedIndices", True, True, -1, 1) + return + +get_A3() diff --git a/Port_Extraction/bank_A4/extract_bank_A4.py b/Port_Extraction/bank_A4/extract_bank_A4.py new file mode 100644 index 0000000..ee478e3 --- /dev/null +++ b/Port_Extraction/bank_A4/extract_bank_A4.py @@ -0,0 +1,51 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kCrocomire_Bg1AndBg2Palette7 = [] +kEnemyInit_Crocomire_Palette2 = [] +kEnemyInit_Crocomire_Palette5 = [] +kCrocomire_Palette1 = [] +kCrocomire_Palette3 = [] +kCrocomire_SpritemapPtrs = [] +kCrocomire_BridgeCrumbleTab0 = [] +kCrocomire_Bg2TilemapIndices0 = [] +kCrocomire_Bg2TilemapIndices1 = [] +kCrocoVlineRandomPos = [] +kCrocomire_Tab0 = [] +kCrocomire_TilesDestinationAddresses = [] +kCrocomire_TilesSourceAddresses = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_A4(): + rom.get_data(0xA4, 0xB89D, 0xB8BD, "uint16", kCrocomire_Bg1AndBg2Palette7, "kCrocomire_Bg1AndBg2Palette7", True, True, -1, 1) + rom.get_data(0xA4, 0xB8BD, 0xB8DD, "uint16", kEnemyInit_Crocomire_Palette2, "kEnemyInit_Crocomire_Palette2", True, True, -1, 1) + rom.get_data(0xA4, 0xB8DD, 0xB8FD, "uint16", kEnemyInit_Crocomire_Palette5, "kEnemyInit_Crocomire_Palette5", True, True, -1, 1) + rom.get_data(0xA4, 0xB8FD, 0xB91D, "uint16", kCrocomire_Palette1, "kCrocomire_Palette1", True, True, -1, 1) + rom.get_data(0xA4, 0xB91D, 0xB93D, "uint16", kCrocomire_Palette3, "kCrocomire_Palette3", True, True, -1, 1) + rom.get_data(0xA4, 0x8B79, 0x8B9B, "uint16", kCrocomire_SpritemapPtrs, "kCrocomire_SpritemapPtrs", True, True, 8, 1) + rom.get_data(0xA4, 0x9156, 0x916C, "uint16", kCrocomire_BridgeCrumbleTab0, "kCrocomire_BridgeCrumbleTab0", True, True, -1, 1) + rom.get_data(0xA4, 0x9C79, 0x9E7B, "uint16", kCrocomire_Bg2TilemapIndices0, "kCrocomire_Bg2TilemapIndices0", True, True, 16, 1) + rom.get_data(0xA4, 0x9E7B, 0xA07D, "uint16", kCrocomire_Bg2TilemapIndices1, "kCrocomire_Bg2TilemapIndices1", True, True, 16, 1) + + + + + rom.get_data(0xA4, 0x9697, 0x96C8, "uint8", kCrocoVlineRandomPos, "kCrocoVlineRandomPos", False, True, 16, 1) + rom.get_data(0xA4, 0x98CA, 0x990A, "uint16", kCrocomire_Tab0, "kCrocomire_Tab0", True, True, 4, 1) + rom.get_data(0xA4, 0x99CB, 0x99D9, "uint16", kCrocomire_TilesDestinationAddresses, "kCrocomire_TilesDestinationAddresses", True, True, -1, 1) + rom.get_data(0xA4, 0x99D9, 0x99E5, "uint16", kCrocomire_TilesSourceAddresses, "kCrocomire_TilesSourceAddresses", True, True, -1, 1) + #rom.get_data(, 0x, "", , "", , , , ) + return + +#define kCrocomire_MeltingTilesTab0 (*(uint16*)RomFixedPtr(0xa49bc5)) +#define kCrocomire_MeltingTilesTab1 (*(uint16*)RomFixedPtr(0xa49bc7)) +#define kCrocomire_MeltingTilesTab2 (*(uint16*)RomFixedPtr(0xa49bc9)) +#define kCrocomire_MeltingTilesTab3 (*(uint16*)RomFixedPtr(0xa49bcb)) + +get_A4() \ No newline at end of file diff --git a/Port_Extraction/bank_A5/extract_bank_A5.py b/Port_Extraction/bank_A5/extract_bank_A5.py new file mode 100644 index 0000000..2fe6431 --- /dev/null +++ b/Port_Extraction/bank_A5/extract_bank_A5.py @@ -0,0 +1,47 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kDraygon_Palette1 = [] +kDraygon_Bg1AndBg2Palette5 = [] +kDraygon_FlashPalette = [] +kDraygonTurret_XYSpawnPositions = [] +kDraygon_HealthPaletteTable = [] +kDraygon_HealthPaletteThreshold = [] +kMiniDraygon_MovementLatency = [] +kMiniDraygon_DeathSequenceSubspeeds = [] +kMiniDraygon_DeathSequenceSpawnPositions = [] +kMiniDraygon_DeathSequenceAngles = [] +kMiniDraygonIntroDanceTable = [] +kSporeSpawn_HealthPaletteTable = [] +kSporeSpawn_DeathSequencePalette1 = [] +kSporeSpawn_DeathSequnceBg1AndBg2Palette4 = [] +kSporeSpawn_DeathSequenceBg1AndBg2Palette7 = [] +kSporeSpawn_Palette7 = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_A5(): + rom.get_data(0xA5, 0xA217, 0xA237, "uint16", kDraygon_Palette1, "kDraygon_Palette1", True, True, -1, 1) + rom.get_data(0xA5, 0xA277, 0xA297, "uint16", kDraygon_Bg1AndBg2Palette5, "kDraygon_Bg1AndBg2Palette5", True, True, -1, 1) + rom.get_data(0xA5, 0xA297, 0xA2B7, "uint16", kDraygon_FlashPalette, "kDraygon_FlashPalette", True, True, -1, 1) + rom.get_data(0xA5, 0x87DC, 0x87F4, "uint16", kDraygonTurret_XYSpawnPositions, "kDraygonTurret_XYSpawnPositions", False, True, 2, 1) + rom.get_data(0xA5, 0x96AF, 0x96EF, "uint16", kDraygon_HealthPaletteTable, "kDraygon_HealthPaletteTable", True, True, 4, 1) + rom.get_data(0xA5, 0x96EF, 0x9701, "uint16", kDraygon_HealthPaletteThreshold, "kDraygon_HealthPaletteThreshold", False, True, -1, 1) + rom.get_data(0xA5, 0xA19F, 0xA1AF, "uint16", kMiniDraygon_MovementLatency, "kMiniDraygon_MovementLatency", True, True, 4, 1) + rom.get_data(0xA5, 0xA1AF, 0xA1C7, "uint16", kMiniDraygon_DeathSequenceSubspeeds, "kMiniDraygon_DeathSequenceSubspeeds", True, True, 2, 1) + rom.get_data(0xA5, 0xA1C7, 0xA1DF, "uint16", kMiniDraygon_DeathSequenceSpawnPositions, "kMiniDraygon_DeathSequenceSpawnPositions", True, True, 2, 1) + rom.get_data(0xA5, 0xA1DF, 0xA1F7, "uint16", kMiniDraygon_DeathSequenceAngles, "kMiniDraygon_DeathSequenceAngles", True, True, 2, 1) + rom.get_data(0xA5, 0xCE07, 0xDDC7, "uint8", kMiniDraygonIntroDanceTable, "kMiniDraygonIntroDanceTable", True, True, 16, 2) + rom.get_data(0xA5, 0xE379, 0xE3F9, "uint16", kSporeSpawn_HealthPaletteTable, "kSporeSpawn_HealthPaletteTable", True, True, 16, 1) + rom.get_data(0xA5, 0xE3F9, 0xE4F9, "uint16", kSporeSpawn_DeathSequencePalette1, "kSporeSpawn_DeathSequencePalette1", True, True, 16, 1) + rom.get_data(0xA5, 0xE4F9, 0xE5D9, "uint16", kSporeSpawn_DeathSequnceBg1AndBg2Palette4, "kSporeSpawn_DeathSequnceBg1AndBg2Palette4", True, True, 16, 1) + rom.get_data(0xA5, 0xE5D9, 0xE6B9, "uint16", kSporeSpawn_DeathSequenceBg1AndBg2Palette7, "kSporeSpawn_DeathSequenceBg1AndBg2Palette7", True, True, 16, 1) + rom.get_data(0xA5, 0xE359, 0xE379, "uint16", kSporeSpawn_Palette7, "kSporeSpawn_Palette7", True, True, -1, 1) + return + +get_A5() \ No newline at end of file diff --git a/Port_Extraction/bank_A6/extract_bank_A6.py b/Port_Extraction/bank_A6/extract_bank_A6.py new file mode 100644 index 0000000..75db2af --- /dev/null +++ b/Port_Extraction/bank_A6/extract_bank_A6.py @@ -0,0 +1,121 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kCeresRidley_Tab0 = [] +kCeresRidley_Tab0 = [] +kCeresRidley_PaletteTab0 = [] +kCeresRidley_PaletteTab1 = [] +kCeresRidley_PalettePtrs0 = [] +kCeresRidley_FuncPtrs0 = [] +kCeresRidley_Tab1 = [] +kCeresRidley_GetawayYVelocityIndices = [] +kCeresRidley_GetawayXVelocityIndices = [] +kCeresRidley_Mode7TransferPtrs0 = [] +kCeresRidley_Mode7TransferPtrs1 = [] +kRidley_FlyToXPositionTab0 = [] +kRidley_FlyToXPositionTab1 = [] +kRidley_FlyToXPositionTab2 = [] +kRidley_HoldingSamusXPositionTab0 = [] +kRidley_HoldingSamusYPositionTab0 = [] +kRidley_Ptrs0 = [] +kRidley_Ptrs1 = [] +kRidley_Tab0 = [] +kRidley_Tab1 = [] +kRidley_Tab2 = [] +kRidley_Tab3 = [] +kRidley_Bg1AndBg2Palette6 = [] +kRidley_InstrListPtrs0 = [] +kRidley_XPositionIndices0 = [] +kRidley_InstrListPtrs1 = [] +kRidley_XPositionIndices1 = [] +kRidley_InstrListPtrs2 = [] +kRidley_XPositionIndices2 = [] +kRidley_InstrListPtrs3 = [] +kRidley_XPositionIndices3 = [] +kRidley_InstrListPtrs4 = [] +kRidley_XPositionIndices4 = [] +kRidley_InstrListPtrs5 = [] +kRidleysExplosion_Tab0 = [] +kRidley_MinTailAngleIndices0 = [] +kRidley_MaxTailAngleIndices0 = [] +kRidley_TilemapPtrs0 = [] +kRidley_SpritemapPtrs0 = [] +kEnemyInit_CeresSteam_InstrListPtrs = [] +kEnemyInit_CeresSteam_FuncPtrs = [] +kEnemyInit_CeresDoors_FuncPtrs = [] +kEnemyInit_CeresDoors_InstrListPtrs = [] +kCeresDoor_RandomXYPositionIndices = [] +kCeresDoor_Mode7TransferPtrs = [] +kEnemyInit_Zebetites_DestroyedIndices = [] +kEnemyInit_Zebetites_HeightIndices = [] +kEnemyInit_Zebetites_InstrListPtrs = [] +kEnemyInit_Zebetites_XPositionIndices = [] +kEnemyInit_Zebetites_YPositionIndices0 = [] +kEnemyInit_Zebetites_YPositionIndices1 = [] +kZebetites_BigZebetiteInstrListPtrs = [] +kZebetites_SmallZebetitePairInstrListPtrs = [] + + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_A6(): + rom.get_data(0xA6, 0xE269, 0xE2AA, "uint8", kCeresRidley_Tab0, "kCeresRidley_Tab0", False, True, 16, 1) + rom.get_data(0xA6, 0xE2AA, 0xE30A, "uint16", kCeresRidley_PaletteTab0, "kCeresRidley_PaletteTab0", True, True, 3, 1) + rom.get_data(0xA6, 0xE30A, 0xE46A, "uint16", kCeresRidley_PaletteTab1, "kCeresRidley_PaletteTab1", True, True, 11, 1) + rom.get_data(0xA6, 0xA4EB, 0xA50B, "uint16", kCeresRidley_PalettePtrs0, "kCeresRidley_PalettePtrs0", True, True, -1, 1) + rom.get_data(0xA6, 0xA743, 0xA763, "uint16", kCeresRidley_FuncPtrs0, "kCeresRidley_FuncPtrs0", True, True, -1, 1) + rom.get_data(0xA6, 0xAE4D, 0xAF2F, "uint16", kCeresRidley_Tab1, "kCeresRidley_Tab1", True, True, 16, 1) + rom.get_data(0xA6, 0xAF2F, 0xB00F, "uint16", kCeresRidley_GetawayYVelocityIndices, "kCeresRidley_GetawayYVelocityIndices", True, True, 16, 1) + rom.get_data(0xA6, 0xB00F, 0xB0EF, "uint16", kCeresRidley_GetawayXVelocityIndices, "kCeresRidley_GetawayXVelocityIndices", True, True, 16, 1) + rom.get_data(0xA6, 0xACDA, 0xACE2, "uint16", kCeresRidley_Mode7TransferPtrs0, "kCeresRidley_Mode7TransferPtrs0", True, True, -1, 1) + rom.get_data(0xA6, 0xAD45, 0xAD49, "uint16", kCeresRidley_Mode7TransferPtrs1, "kCeresRidley_Mode7TransferPtrs1", True, True, -1, 1) + rom.get_data(0xA6, 0xB60D, 0xB613, "uint16", kRidley_FlyToXPositionTab0, "kRidley_FlyToXPositionTab0", True, True, -1, 1) + rom.get_data(0xA6, 0xB63B, 0xB641, "uint16", kRidley_FlyToXPositionTab1, "kRidley_FlyToXPositionTab1", True, True, -1, 1) + rom.get_data(0xA6, 0xB6C8, 0xB6CE, "uint16", kRidley_FlyToXPositionTab2, "kRidley_FlyToXPositionTab2", True, True, -1, 1) + rom.get_data(0xA6, 0xB9D5, 0xB9DB, "uint16", kRidley_HoldingSamusXPositionTab0, "kRidley_HoldingSamusXPositionTab0", True, True, -1, 1) + rom.get_data(0xA6, 0xB9DB, 0xB9E1, "uint16", kRidley_HoldingSamusYPositionTab0, "kRidley_HoldingSamusYPositionTab0", True, True, -1, 1) + rom.get_data(0xA6, 0xB965, 0xB96D, "uint16", kRidley_Ptrs0, "kRidley_Ptrs0", True, True, -1, 1) + rom.get_data(0xA6, 0xB96D, 0xB975, "uint16", kRidley_Ptrs1, "kRidley_Ptrs1", True, True, -1, 1) + rom.get_data(0xA6, 0xB94D, 0xB959, "uint16", kRidley_Tab0, "kRidley_Tab0", False, True, -1, 1) + rom.get_data(0xA6, 0xB959, 0xB965, "uint16", kRidley_Tab1, "kRidley_Tab1", False, True, -1, 1) + rom.get_data(0xA6, 0xBB48, 0xBB4E, "uint16", kRidley_Tab2, "kRidley_Tab2", True, True, -1, 1) + rom.get_data(0xA6, 0xBB4E, 0xBB56, "uint16", kRidley_Tab3, "kRidley_Tab3", False, True, -1, 1) + rom.get_data(0xA6, 0xC1DF, 0xC23F, "uint16", kRidley_Bg1AndBg2Palette6, "kRidley_Bg1AndBg2Palette6", True, True, 3, 1) + rom.get_data(0xA6, 0xC7BA, 0xC7DA, "uint16", kRidley_InstrListPtrs0, "kRidley_InstrListPtrs0", True, True, -1, 1) + rom.get_data(0xA6, 0xC804, 0xC808, "uint16", kRidley_XPositionIndices0, "kRidley_XPositionIndices0", False, True, -1, 1) + rom.get_data(0xA6, 0xC808, 0xC80C, "uint16", kRidley_InstrListPtrs1, "kRidley_InstrListPtrs1", True, True, -1, 1) + rom.get_data(0xA6, 0xC836, 0xC83A, "uint16", kRidley_XPositionIndices1, "kRidley_XPositionIndices1", True, True, -1, 1) + rom.get_data(0xA6, 0xC83A, 0xC83E, "uint16", kRidley_InstrListPtrs2, "kRidley_InstrListPtrs2", True, True, -1, 1) + rom.get_data(0xA6, 0xC868, 0xC86C, "uint16", kRidley_XPositionIndices2, "kRidley_XPositionIndices2", True, True, -1, 1) + rom.get_data(0xA6, 0xC86C, 0xC870, "uint16", kRidley_InstrListPtrs3, "kRidley_InstrListPtrs3", True, True, -1, 1) + rom.get_data(0xA6, 0xC89A, 0xC89E, "uint16", kRidley_XPositionIndices3, "kRidley_XPositionIndices3", True, True, -1, 1) + rom.get_data(0xA6, 0xC89E, 0xC8A2, "uint16", kRidley_InstrListPtrs4, "kRidley_InstrListPtrs4", True, True, -1, 1) + rom.get_data(0xA6, 0xC8CC, 0xC8D0, "uint16", kRidley_XPositionIndices4, "kRidley_XPositionIndices4", True, True, -1, 1) + rom.get_data(0xA6, 0xC8D0, 0xC8D4, "uint16", kRidley_InstrListPtrs5, "kRidley_InstrListPtrs5", True, True, -1, 1) + rom.get_data(0xA6, 0xC6CE, 0xC6E6, "uint16", kRidleysExplosion_Tab0, "kRidleysExplosion_Tab0", False, True, -1, 1) + rom.get_data(0xA6, 0xCC12, 0xCC18, "uint16", kRidley_MinTailAngleIndices0, "kRidley_MinTailAngleIndices0", True, True, -1, 1) + rom.get_data(0xA6, 0xCC18, 0xCC1E, "uint16", kRidley_MaxTailAngleIndices0, "kRidley_MaxTailAngleIndices0", True, True, -1, 1) + rom.get_data(0xA6, 0xDB02, 0xDB2A, "uint16", kRidley_TilemapPtrs0, "kRidley_TilemapPtrs0", True, True, 10, 1) + rom.get_data(0xA6, 0xDCBA, 0xDCDA, "uint16", kRidley_SpritemapPtrs0, "kRidley_SpritemapPtrs0", True, True, -1, 1) + rom.get_data(0xA6, 0xEFF5, 0xF001, "uint16", kEnemyInit_CeresSteam_InstrListPtrs, "kEnemyInit_CeresSteam_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA6, 0xF001, 0xF00D, "uint16", kEnemyInit_CeresSteam_FuncPtrs, "kEnemyInit_CeresSteam_FuncPtrs", True, True, -1, 1) + rom.get_data(0xA6, 0xF72B, 0xF739, "uint16", kEnemyInit_CeresDoors_FuncPtrs, "kEnemyInit_CeresDoors_FuncPtrs", True, True, -1, 1) + rom.get_data(0xA6, 0xF52C, 0xF53A, "uint16", kEnemyInit_CeresDoors_InstrListPtrs, "kEnemyInit_CeresDoors_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA6, 0xF840, 0xF850, "uint16", kCeresDoor_RandomXYPositionIndices, "kCeresDoor_RandomXYPositionIndices", True, True, -1, 2) + rom.get_data(0xA6, 0xF900, 0xF904, "uint16", kCeresDoor_Mode7TransferPtrs, "kCeresDoor_Mode7TransferPtrs", True, True, -1, 1) + rom.get_data(0xA6, 0xFC03, 0xFC0B, "uint16", kEnemyInit_Zebetites_DestroyedIndices, "kEnemyInit_Zebetites_DestroyedIndices", True, True, -1, 1) + rom.get_data(0xA6, 0xFC0B, 0xFC13, "uint16", kEnemyInit_Zebetites_HeightIndices, "kEnemyInit_Zebetites_HeightIndices", False, True, -1, 1) + rom.get_data(0xA6, 0xFC13, 0xFC1B, "uint16", kEnemyInit_Zebetites_InstrListPtrs, "kEnemyInit_Zebetites_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA6, 0xFC1B, 0xFC23, "uint16", kEnemyInit_Zebetites_XPositionIndices, "kEnemyInit_Zebetites_XPositionIndices", False, True, -1, 1) + rom.get_data(0xA6, 0xFC23, 0xFC2B, "uint16", kEnemyInit_Zebetites_YPositionIndices0, "kEnemyInit_Zebetites_YPositionIndices0", False, True, -1, 1) + rom.get_data(0xA6, 0xFC2B, 0xFC33, "uint16", kEnemyInit_Zebetites_YPositionIndices1, "kEnemyInit_Zebetites_YPositionIndices1", False, True, -1, 1) + rom.get_data(0xA6, 0xFD4A, 0xFD54, "uint16", kZebetites_BigZebetiteInstrListPtrs, "kZebetites_BigZebetiteInstrListPtrs", True, True, -1, 1) + rom.get_data(0xA6, 0xFD54, 0xFD5E, "uint16", kZebetites_SmallZebetitePairInstrListPtrs, "kZebetites_SmallZebetitePairInstrListPtrs", True, True, -1, 1) + return + +get_A6() \ No newline at end of file diff --git a/Port_Extraction/bank_A7/extract_bank_A7.py b/Port_Extraction/bank_A7/extract_bank_A7.py new file mode 100644 index 0000000..efb5738 --- /dev/null +++ b/Port_Extraction/bank_A7/extract_bank_A7.py @@ -0,0 +1,87 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kKraid_BgTargetPalette6 = [] +kKraid_BgTargetPalette3 = [] +kEproj_RocksFallingKraidCeilingXPositions = [] +kKraid_InvulnerableRoarInstrLists = [] +kKraid_VulnerableRoarInstrLists = [] +kKraid_BodyHitboxTable = [] +kKraid_BgPalette7 = [] +kKraid_BgPalette7_KraidDeath = [] +kKraid_SprPalette7 = [] +kKraid_EyeGlowingInstrLists = [] +kKraid_DyingInstrLists = [] +kKraid_LintBoundary = [] +kKraid_XMovementTable = [] +kEproj_RocksKraidSpits_RandomParameters = [] +kKraid_GoodFingernailInstrLists = [] +kKraidsFingernail_UpwardsVelocityTable = [] +kKraidsFingernail_DownwardsVelocityTable = [] +kKraidsFingernail_BoundaryOffsets = [] +kKraidSinkEntry = [] +kPhantoon_InstrListPtrs = [] +kPhantoon_MaterialisationSoundEffects = [] +kPhantoon_BrokenCode = [] +kEproj_DestroyableFireballs_Positions = [] +kPhantoon_CasualFlameTimerPtrs = [] +kPhantoon_Figure8VulnerabilityTimers = [] +kPhantoon_EyeClosedTimers = [] +kPhantoon_FireballRainHidingTimers = [] +kPhantoon_EyeballDirectionInstrListPtrs = [] +kPhantoon_FlameRainSpawnPositions = [] +kPhantoon_DyingExplosionsTable = [] +kPhantoon_HealthPalettePtrs = [] +kDachora_PalettePtrs_1 = [] +kDachora_PalettePtrs_2 = [] +kPhantoon_FadeOutTargetPalettes = [] +kWreckedShipOn_Bg1AndBg2TargetPalettes = [] +kSpritePaletteRamPtrs = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_A7(): + rom.get_data(0xA7, 0x86C7, 0x86E7, "uint16", kKraid_BgTargetPalette6, "kKraid_BgTargetPalette6", True, True, -1, 1) + rom.get_data(0xA7, 0xAAA6, 0xAAC6, "uint16", kKraid_BgTargetPalette3, "kKraid_BgTargetPalette3", True, True, -1, 1) + rom.get_data(0xA7, 0xACB3, 0xACC5, "uint16", kEproj_RocksFallingKraidCeilingXPositions, "kEproj_RocksFallingKraidCeilingXPositions", False, True, -1, 1) + rom.get_data(0xA7, 0x96D2, 0x96DA, "KraidInstrList", kKraid_InvulnerableRoarInstrLists, "kKraid_InvulnerableRoarInstrLists", True, False, -1, 1) + rom.get_data(0xA7, 0x96DA, 0x96DB, "KraidInstrList", kKraid_VulnerableRoarInstrLists, "kKraid_VulnerableRoarInstrLists", True, False, -1, 1) + rom.get_data(0xA7, 0xB161, 0xB180, "uint16", kKraid_BodyHitboxTable, "kKraid_BodyHitboxTable", True, True, 2, 1) + rom.get_data(0xA7, 0xB3D3, 0xB3F3, "uint16", kKraid_BgPalette7, "kKraid_BgPalette7", True, True, -1, 1) + rom.get_data(0xA7, 0xB4F3, 0xB513, "uint16", kKraid_BgPalette7_KraidDeath, "kKraid_BgPalette7_KraidDeath", True, True, -1, 1) + rom.get_data(0xA7, 0xB513, 0xB533, "uint16", kKraid_SprPalette7, "kKraid_SprPalette7", True, True, -1, 1) + rom.get_data(0xA7, 0x974A, 0x9764, "KraidInstrList", kKraid_EyeGlowingInstrLists, "kKraid_EyeGlowingInstrLists", True, True, 1, 1) + rom.get_data(0xA7, 0x9764, 0x9788, "KraidInstrList", kKraid_DyingInstrLists, "kKraid_DyingInstrLists", True, True, 1, 1) + rom.get_data(0xA7, 0x92B7, 0x92C3, "Hitbox", kKraid_LintBoundary, "kKraid_LintBoundary", True, False, -1, 1) + rom.get_data(0xA7, 0xBA7D, 0xBA95, "uint16", kKraid_XMovementTable, "kKraid_XMovementTable", True, True, 2, 1) + rom.get_data(0xA7, 0xBC65, 0xBC75, "uint16", kEproj_RocksKraidSpits_RandomParameters, "kEproj_RocksKraidSpits_RandomParameters", True, True, -1, 1) + rom.get_data(0xA7, 0x8B0A, 0x8B0E, "SpriteDrawInstr", kKraid_GoodFingernailInstrLists, "kKraid_GoodFingernailInstrLists", True, False, -1, 1) + rom.get_data(0xA7, 0xBE3E, 0xBE46, "uint16", kKraidsFingernail_UpwardsVelocityTable, "kKraidsFingernail_UpwardsVelocityTable", True, True, -1, 1) + rom.get_data(0xA7, 0xBE46, 0xBE4E, "uint16", kKraidsFingernail_DownwardsVelocityTable, "kKraidsFingernail_DownwardsVelocityTable", True, True, -1, 1) + rom.get_data(0xA7, 0xBF1D, 0xBF2D, "uint16", kKraidsFingernail_BoundaryOffsets, "kKraidsFingernail_BoundaryOffsets", True, True, 2, 1) + rom.get_data(0xA7, 0xC5E7, 0xC691, "KraidSinkTable", kKraidSinkEntry, "kKraidSinkEntry", True, True, 1, 1) + rom.get_data(0xA7, 0xCE8E, 0xCE96, "uint16", kPhantoon_InstrListPtrs, "kPhantoon_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA7, 0xCDED, 0xCDF3, "uint16", kPhantoon_MaterialisationSoundEffects, "kPhantoon_MaterialisationSoundEffects", True, True, -1, 1) + rom.get_data(0xA7, 0x902D, 0x9055, "ExtendedSpriteMap", kPhantoon_BrokenCode, "kPhantoon_BrokenCode", True, True, 1, 1) + rom.get_data(0xA7, 0xCFC2, 0xCFCA, "uint8", kEproj_DestroyableFireballs_Positions, "kEproj_DestroyableFireballs_Positions", False, True, -1, 1) + rom.get_data(0xA7, 0xCCFD, 0xCD05, "uint16", kPhantoon_CasualFlameTimerPtrs, "kPhantoon_CasualFlameTimerPtrs", True, True, -1, 1) + rom.get_data(0xA7, 0xCD41, 0xCD51, "uint16", kPhantoon_Figure8VulnerabilityTimers, "kPhantoon_Figure8VulnerabilityTimers", False, True, -1, 1) + rom.get_data(0xA7, 0xCD53, 0xCD63, "uint16", kPhantoon_EyeClosedTimers, "kPhantoon_EyeClosedTimers", False, True, -1, 1) + rom.get_data(0xA7, 0xCD63, 0xCD73, "uint16", kPhantoon_FireballRainHidingTimers, "kPhantoon_FireballRainHidingTimers", False, True, -1, 1) + rom.get_data(0xA7, 0xD40D, 0xD421, "uint16", kPhantoon_EyeballDirectionInstrListPtrs, "kPhantoon_EyeballDirectionInstrListPtrs", True, True, -1, 1) + rom.get_data(0xA7, 0xCDAD, 0xCDED, "uint16", kPhantoon_FlameRainSpawnPositions, "kPhantoon_FlameRainSpawnPositions", False, True, 4, 1) + rom.get_data(0xA7, 0xDA1D, 0xDA51, "uint8", kPhantoon_DyingExplosionsTable, "kPhantoon_DyingExplosionsTable", False, True, 4, 1) + rom.get_data(0xA7, 0xDC4A, 0xDC5A, "uint16", kPhantoon_HealthPalettePtrs, "kPhantoon_HealthPalettePtrs", True, True, -1, 1) + rom.get_data(0xA7, 0xF787, 0xF78F, "uint16", kDachora_PalettePtrs_1, "kDachora_PalettePtrs_1", True, True, -1, 1) + rom.get_data(0xA7, 0xF92D, 0xF935, "uint16", kDachora_PalettePtrs_2, "kDachora_PalettePtrs_2", True, True, -1, 1) + rom.get_data(0xA7, 0xCA41, 0xCA61, "uint16", kPhantoon_FadeOutTargetPalettes, "kPhantoon_FadeOutTargetPalettes", False, True, -1, 1) + rom.get_data(0xA7, 0xCA61, 0xCB41, "uint16", kWreckedShipOn_Bg1AndBg2TargetPalettes, "kWreckedShipOn_Bg1AndBg2TargetPalettes", True, True, 16, 1) + rom.get_data(0xA7, 0xF55F, 0xF56F, "uint16", kSpritePaletteRamPtrs, "kSpritePaletteRamPtrs", True, True, -1, 1) + return + +get_A7() \ No newline at end of file diff --git a/Port_Extraction/bank_A8/extract_bank_A8.py b/Port_Extraction/bank_A8/extract_bank_A8.py new file mode 100644 index 0000000..31d4618 --- /dev/null +++ b/Port_Extraction/bank_A8/extract_bank_A8.py @@ -0,0 +1,69 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kEnemyInit_MorphBallEye_InstrListPtrs = [] +kYappingMaw_Constants = [] +kYappingMaw_Constant0 = [] +kYappingMaw_Constant1 = [] +kYappingMaw_Constant2 = [] +kYappingMaw_Constant3 = [] +kYappingMaw_Constant4 = [] +kYappingMaw_Constant5 = [] +kYappingMaw_Constant6 = [] +kYappingMaw_Constant7 = [] +kYappingMaw_Constant8 = [] +kYappingMaw_Constant9 = [] +kYappingMaw_Constant10 = [] +kYappingMaw_Constant11 = [] +kYappingMaw_InstrListPtrs = [] +kNorfairLavaMan_Palette = [] +kNorfairLavaMan_Tab2 = [] +kNorfairLavaMan_Tab0 = [] +kNorfairLavaMan_Tab1 = [] +kBeetom_SamusNotInProximityFuncPtrs = [] +kMaridiaFloater_InstrListPtrs = [] +kEnemyInit_WreckedShipRobotDeactivated_InstrListPtrs = [] +kEnemyInit_WreckedShipOrbs_InstrListPtrs = [] +kEnemyInit_WreckedShipSpark_InstrListPtrs = [] +kEnemyInit_WreckedShipSpark_FuncPtrs = [] +kBlueBrinstarFaceBlock_GlowPalette = [] +kKiHunter_InstrListPtrs = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_A8(): + rom.get_data(0xA8, 0x90DA, 0x90E2, "uint16", kEnemyInit_MorphBallEye_InstrListPtrs, "kEnemyInit_MorphBallEye_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA8, 0xA0A7, 0xA0C7, "uint16", kYappingMaw_Constants, "kYappingMaw_Constants", True, True, -1, 1) + rom.get_data(0xA8, 0xA0A7, 0xA0A9, "uint16", kYappingMaw_Constant0, "kYappingMaw_Constant0", True, False, -1, 1) + rom.get_data(0xA8, 0xA0A9, 0xA0AB, "uint16", kYappingMaw_Constant1, "kYappingMaw_Constant1", True, False, -1, 1) + rom.get_data(0xA8, 0xA0AB, 0xA0AD, "uint16", kYappingMaw_Constant2, "kYappingMaw_Constant2", True, False, -1, 1) + rom.get_data(0xA8, 0xA0AD, 0xA0AF, "uint16", kYappingMaw_Constant3, "kYappingMaw_Constant3", True, False, -1, 1) + rom.get_data(0xA8, 0xA0B3, 0xA0B5, "uint16", kYappingMaw_Constant4, "kYappingMaw_Constant4", True, False, -1, 1) + rom.get_data(0xA8, 0xA0B5, 0xA0B7, "uint16", kYappingMaw_Constant5, "kYappingMaw_Constant5", True, False, -1, 1) + rom.get_data(0xA8, 0xA0B7, 0xA0B9, "uint16", kYappingMaw_Constant6, "kYappingMaw_Constant6", True, False, -1, 1) + rom.get_data(0xA8, 0xA0B9, 0xA0BB, "uint16", kYappingMaw_Constant7, "kYappingMaw_Constant7", True, False, -1, 1) + rom.get_data(0xA8, 0xA0BB, 0xA0BD, "uint16", kYappingMaw_Constant8, "kYappingMaw_Constant8", True, False, -1, 1) + rom.get_data(0xA8, 0xA0BD, 0xA0BF, "uint16", kYappingMaw_Constant9, "kYappingMaw_Constant9", True, False, -1, 1) + rom.get_data(0xA8, 0xA0C3, 0xA0C5, "uint16", kYappingMaw_Constant10, "kYappingMaw_Constant10", True, False, -1, 1) + rom.get_data(0xA8, 0xA0C5, 0xA0C7, "uint16", kYappingMaw_Constant11, "kYappingMaw_Constant11", True, False, -1, 1) + rom.get_data(0xA8, 0xA097, 0xA0A7, "uint16", kYappingMaw_InstrListPtrs, "kYappingMaw_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA8, 0xAC1C, 0xAC9C, "uint16", kNorfairLavaMan_Palette, "kNorfairLavaMan_Palette", True, True, 16, 1) + rom.get_data(0xA8, 0xAF79, 0xAF8B, "uint16", kNorfairLavaMan_Tab2, "kNorfairLavaMan_Tab2", False, True, -1, 1) + rom.get_data(0xA8, 0xAF55, 0xAF67, "uint16", kNorfairLavaMan_Tab0, "kNorfairLavaMan_Tab0", False, True, -1, 1) + rom.get_data(0xA8, 0xAF67, 0xAF79, "uint16", kNorfairLavaMan_Tab1, "kNorfairLavaMan_Tab1", True, True, -1, 1) + rom.get_data(0xA8, 0xB74E, 0xB75E, "uint16", kBeetom_SamusNotInProximityFuncPtrs, "kBeetom_SamusNotInProximityFuncPtrs", True, True, 2, 1) + rom.get_data(0xA8, 0xC599, 0xC59F, "uint16", kMaridiaFloater_InstrListPtrs, "kMaridiaFloater_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA8, 0xCC30, 0xCC36, "uint16", kEnemyInit_WreckedShipRobotDeactivated_InstrListPtrs, "kEnemyInit_WreckedShipRobotDeactivated_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA8, 0xE380, 0xE388, "uint16", kEnemyInit_WreckedShipOrbs_InstrListPtrs, "kEnemyInit_WreckedShipOrbs_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA8, 0xE682, 0xE688, "uint16", kEnemyInit_WreckedShipSpark_InstrListPtrs, "kEnemyInit_WreckedShipSpark_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA8, 0xE688, 0xE68E, "uint16", kEnemyInit_WreckedShipSpark_FuncPtrs, "kEnemyInit_WreckedShipSpark_FuncPtrs", True, True, -1, 1) + rom.get_data(0xA8, 0xE7CC, 0xE80C, "uint16", kBlueBrinstarFaceBlock_GlowPalette, "kBlueBrinstarFaceBlock_GlowPalette", True, True, 4, 1) + rom.get_data(0xA8, 0xF3B0, 0xF3B8, "uint16", kKiHunter_InstrListPtrs, "kKiHunter_InstrListPtrs", True, True, -1, 2) + return + +get_A8() \ No newline at end of file diff --git a/Port_Extraction/bank_A9/extract_bank_A9.py b/Port_Extraction/bank_A9/extract_bank_A9.py new file mode 100644 index 0000000..14bd2ef --- /dev/null +++ b/Port_Extraction/bank_A9/extract_bank_A9.py @@ -0,0 +1,65 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kMotherBrain_FakeDeathExplosionsXYPositions = [] +kMotherBrainTubesFallingFuncPtrs = [] +kMotherBrain_ExplosionsXYOffsets = [] +kMotherBrain_AttackInstrListPtrs = [] +kMotherBrain_RainbowBeamPalettes = [] +kMotherBrain_WalkForwardsFuncPtrs = [] +kMotherBrain_WalkBackwardsFuncPtrs = [] +kShitroid_FadingToBlack = [] +kShitroid_DeathExplosionsXYOffsets = [] +kShitroid_HealthBasedPalettes_Shell = [] +kShitroid_HealthBasedPalettes_Innards = [] +kMotherBrain_PaletteSetPtrs = [] +kDeadTorizo_VramWriteTableIndices_1 = [] +kDeadTorizo_VramWriteTableIndices_2 = [] +kDeadTorizo_SandHeapDestinationOffsets = [] +kDeadTorizo_SandHeapSourceOffsets = [] +kDeadTorizo_TileData = [] +kDeadZoomer_InstrListPtrs = [] +kDeadZoomer_CorpseRottingDefinitionPtrs = [] +kDeadRipper_InstrListPtrs = [] +kDeadRipper_CorpseRottingDefinitionPtrs = [] +kDeadSkree_InstrListPtrs = [] +kDeadSkree_CorpseRottingDefinitionPtrs = [] +kDeadMonsters_Tab0 = [] +kDeadMonsters_Tab1 = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_A9(): + rom.get_data(0xA9, 0x8929, 0x8949, "uint16", kMotherBrain_FakeDeathExplosionsXYPositions, "kMotherBrain_FakeDeathExplosionsXYPositions", False, True, 2, 1) + rom.get_data(0xA9, 0x8B7B, 0x8B85, "uint16", kMotherBrainTubesFallingFuncPtrs, "kMotherBrainTubesFallingFuncPtrs", True, True, -1, 1) + rom.get_data(0xA9, 0xB099, 0xB109, "uint16", kMotherBrain_ExplosionsXYOffsets, "kMotherBrain_ExplosionsXYOffsets", True, True, 8, 2) + rom.get_data(0xA9, 0xB6D4, 0xB6DC, "uint16", kMotherBrain_AttackInstrListPtrs, "kMotherBrain_AttackInstrListPtrs", True, True, -1, 1) + rom.get_data(0xAD, 0xE434, 0xE44A, "uint16", kMotherBrain_RainbowBeamPalettes, "kMotherBrain_RainbowBeamPalettes", True, True, -1, 1) + rom.get_data(0xA9, 0xC61E, 0xC62A, "uint16", kMotherBrain_WalkForwardsFuncPtrs, "kMotherBrain_WalkForwardsFuncPtrs", True, True, -1, 1) + rom.get_data(0xA9, 0xC664, 0xC670, "uint16", kMotherBrain_WalkBackwardsFuncPtrs, "kMotherBrain_WalkBackwardsFuncPtrs", True, True, -1, 1) + rom.get_data(0xAD, 0xE8E2, 0xE8F0, "uint16", kShitroid_FadingToBlack, "kShitroid_FadingToBlack", True, True, -1, 1) + rom.get_data(0xA9, 0xCDFC, 0xCE24, "uint16", kShitroid_DeathExplosionsXYOffsets, "kShitroid_DeathExplosionsXYOffsets", True, True, 2, 1) + rom.get_data(0xAD, 0xE7E2, 0xE7F2, "uint16", kShitroid_HealthBasedPalettes_Shell, "kShitroid_HealthBasedPalettes_Shell", True, True, -1, 1) + rom.get_data(0xAD, 0xE882, 0xE892, "uint16", kShitroid_HealthBasedPalettes_Innards, "kShitroid_HealthBasedPalettes_Innards", True, True, -1, 1) + rom.get_data(0xA9, 0xD260, 0xD264, "uint16", kMotherBrain_PaletteSetPtrs, "kMotherBrain_PaletteSetPtrs", True, True, -1, 1) + rom.get_data(0xA9, 0xD583, 0xD5BD, "uint16", kDeadTorizo_VramWriteTableIndices_1, "kDeadTorizo_VramWriteTableIndices_1", True, True, 4, 1) + rom.get_data(0xA9, 0xD549, 0xD583, "uint16", kDeadTorizo_VramWriteTableIndices_2, "kDeadTorizo_VramWriteTableIndices_2", True, True, 4, 1) + rom.get_data(0xA9, 0xD67C, 0xD69C, "uint16", kDeadTorizo_SandHeapDestinationOffsets, "kDeadTorizo_SandHeapDestinationOffsets", True, True, -1, 1) + rom.get_data(0xA9, 0xD69C, 0xD6BC, "uint16", kDeadTorizo_SandHeapSourceOffsets, "kDeadTorizo_SandHeapSourceOffsets", True, True, -1, 1) + #rom.get_data(0xB7, 0xA800, 0xA80F, "uint16", kDeadTorizo_TileData, "kDeadTorizo_TileData", True, True, -1, 1) + rom.get_data(0xA9, 0xD86A, 0xD870, "uint16", kDeadZoomer_InstrListPtrs, "kDeadZoomer_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA9, 0xD870, 0xD876, "uint16", kDeadZoomer_CorpseRottingDefinitionPtrs, "kDeadZoomer_CorpseRottingDefinitionPtrs", True, True, -1, 1) + rom.get_data(0xA9, 0xD897, 0xD89B, "uint16", kDeadRipper_InstrListPtrs, "kDeadRipper_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA9, 0xD89B, 0xD89F, "uint16", kDeadRipper_CorpseRottingDefinitionPtrs, "kDeadRipper_CorpseRottingDefinitionPtrs", True, True, -1, 1) + rom.get_data(0xA9, 0xD8C0, 0xD8C6, "uint16", kDeadSkree_InstrListPtrs, "kDeadSkree_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xA9, 0xD8C6, 0xD8CC, "uint16", kDeadSkree_CorpseRottingDefinitionPtrs, "kDeadSkree_CorpseRottingDefinitionPtrs", True, True, -1, 1) + rom.get_data(0xA9, 0xD951, 0xD959, "uint16", kDeadMonsters_Tab0, "kDeadMonsters_Tab0", True, True, -1, 1) + rom.get_data(0xA9, 0xD959, 0xD961, "uint16", kDeadMonsters_Tab1, "kDeadMonsters_Tab1", True, True, -1, 1) + return + +get_A9() \ No newline at end of file diff --git a/Port_Extraction/bank_AA/extract_bank_AA.py b/Port_Extraction/bank_AA/extract_bank_AA.py new file mode 100644 index 0000000..988882c --- /dev/null +++ b/Port_Extraction/bank_AA/extract_bank_AA.py @@ -0,0 +1,61 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kEnemyInit_Torizo_InstrListPtrs = [] +kEnemyInit_TourianEntranceStatue_InstrListPtrs = [] +kEnemyInit_TourianEntranceStatue_PaletteTab0 = [] +kEnemyInit_TourianEntranceStatue_PaletteTab1 = [] +kShaktool_InstrListPtrs0 = [] +kShaktool_InstrListPtrs1 = [] +kSine = [] +kCosine = [] +kNegativeSine = [] +kNegativeCosine_0 = [] +kNegativeCosine = [] +kShaktool_InstrListPtrs2 = [] +kEnemyInit_Shaktool_PropertiesIndices = [] +kEnemyInit_Shaktool_RamOffsetIndices = [] +kEnemyInit_Shaktool_InitialAnglesIndices = [] +kEnemyInit_Shaktool_FuncPtrs = [] +kEnemyInit_Shaktool_ZeroIndices = [] +kEnemyInit_Shaktool_LayerControlIndices = [] +kShaktool_XDirectionIndices = [] +kShaktool_SamusXPositionIndices = [] +kShaktool_SamusYPositionIndices = [] +kN00bTubeCracks_Palette2 = [] +kEnemyInit_ChozoStatue_InstrListPtrs = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_AA(): + rom.get_data(0xAA, 0xC967, 0xC96B, "uint16", kEnemyInit_Torizo_InstrListPtrs, "kEnemyInit_Torizo_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xAA, 0xD810, 0xD816, "uint16", kEnemyInit_TourianEntranceStatue_InstrListPtrs, "kEnemyInit_TourianEntranceStatue_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xAA, 0xD765, 0xD785, "uint16", kEnemyInit_TourianEntranceStatue_PaletteTab0, "kEnemyInit_TourianEntranceStatue_PaletteTab0", True, True, -1, 1) + rom.get_data(0xAA, 0xD785, 0xD7A5, "uint16", kEnemyInit_TourianEntranceStatue_PaletteTab1, "kEnemyInit_TourianEntranceStatue_PaletteTab1", True, True, -1, 1) + rom.get_data(0xAA, 0xDF13, 0xDF21, "uint16", kShaktool_InstrListPtrs0, "kShaktool_InstrListPtrs0", True, True, -1, 1) + rom.get_data(0xAA, 0xDF21, 0xDF2F, "uint16", kShaktool_InstrListPtrs1, "kShaktool_InstrListPtrs1", True, True, -1, 1) + rom.get_data(0xAA, 0xE0BD, 0xE13D, "uint16", kSine, "kSine", True, True, 16, 1) + rom.get_data(0xAA, 0xE13D, 0xE1BD, "uint16", kCosine, "kCosine", True, True, 16, 1) + rom.get_data(0xAA, 0xE1BD, 0xE23D, "uint16", kNegativeSine, "kNegativeSine", True, True, 16, 1) + rom.get_data(0xAA, 0xE23D, 0xE2BD, "uint16", kNegativeCosine_0, "kNegativeCosine_0", True, True, 16, 1) + rom.get_data(0xAA, 0xE03D, 0xE0BD, "uint16", kNegativeCosine, "kNegativeCosine", True, True, 16, 1) + rom.get_data(0xAA, 0xDD15, 0xDD25, "uint16", kShaktool_InstrListPtrs2, "kShaktool_InstrListPtrs2", True, True, -1, 1) + rom.get_data(0xAA, 0xDE95, 0xDEA3, "uint16", kEnemyInit_Shaktool_PropertiesIndices, "kEnemyInit_Shaktool_PropertiesIndices", True, True, -1, 1) + rom.get_data(0xAA, 0xDEA3, 0xDEB1, "uint16", kEnemyInit_Shaktool_RamOffsetIndices, "kEnemyInit_Shaktool_RamOffsetIndices", True, True, -1, 1) + rom.get_data(0xAA, 0xDEB1, 0xDEBF, "uint16", kEnemyInit_Shaktool_InitialAnglesIndices, "kEnemyInit_Shaktool_InitialAnglesIndices", True, True, -1, 1) + rom.get_data(0xAA, 0xDEDB, 0xDEE9, "uint16", kEnemyInit_Shaktool_FuncPtrs, "kEnemyInit_Shaktool_FuncPtrs", True, True, -1, 1) + rom.get_data(0xAA, 0xDEF7, 0xDF05, "uint16", kEnemyInit_Shaktool_ZeroIndices, "kEnemyInit_Shaktool_ZeroIndices", False, True, -1, 1) + rom.get_data(0xAA, 0xDECD, 0xDEDB, "uint16", kEnemyInit_Shaktool_LayerControlIndices, "kEnemyInit_Shaktool_LayerControlIndices", False, True, -1, 1) + rom.get_data(0xAA, 0xE630, 0xE670, "uint16", kShaktool_XDirectionIndices, "kShaktool_XDirectionIndices", True, True, 16, 1) + rom.get_data(0xAA, 0xE670, 0xE6B0, "uint16", kShaktool_SamusXPositionIndices, "kShaktool_SamusXPositionIndices", True, True, 16, 1) + rom.get_data(0xAA, 0xE6B0, 0xE6F0, "uint16", kShaktool_SamusYPositionIndices, "kShaktool_SamusYPositionIndices", True, True, 16, 1) + rom.get_data(0xAA, 0xE2DD, 0xE31D, "uint16", kN00bTubeCracks_Palette2, "kN00bTubeCracks_Palette2", True, True, -1, 1) + rom.get_data(0xAA, 0xE7A2, 0xE7A6, "uint16", kEnemyInit_ChozoStatue_InstrListPtrs, "kEnemyInit_ChozoStatue_InstrListPtrs", True, True, -1, 1) + return + +get_AA() \ No newline at end of file diff --git a/Port_Extraction/bank_AD/extract_bank_AD.py b/Port_Extraction/bank_AD/extract_bank_AD.py new file mode 100644 index 0000000..86feae7 --- /dev/null +++ b/Port_Extraction/bank_AD/extract_bank_AD.py @@ -0,0 +1,31 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kMotherBrain_HealthBasedPalettes_Brain = [] +kMotherBrain_HealthBasedPalettes_BackLeg = [] +kMotherBrain_FadePalToBlack = [] +kMotherBrain_TransitionToFromGrey_Incr = [] +kMotherBrain_TransitionToFromGrey_Decr = [] +kMotherBrain_FadeToGray_Drained = [] +kMotherBrain_FadeToGray_RealDeath = [] +kMotherBrain_Phase3_TurnLightsBackOn = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_AD(): + rom.get_data(0xAD, 0xE6A2, 0xE6AC, "uint16", kMotherBrain_HealthBasedPalettes_Brain, "kMotherBrain_HealthBasedPalettes_Brain", True, True, -1, 1) + rom.get_data(0xAD, 0xE742, 0xE74C, "uint16", kMotherBrain_HealthBasedPalettes_BackLeg, "kMotherBrain_HealthBasedPalettes_BackLeg", True, True, -1, 1) + rom.get_data(0xAD, 0xE9E8, 0xEA0A, "uint16", kMotherBrain_FadePalToBlack, "kMotherBrain_FadePalToBlack", True, True, 16, 1) + rom.get_data(0xAD, 0xED8A, 0xED9C, "uint16", kMotherBrain_TransitionToFromGrey_Incr, "kMotherBrain_TransitionToFromGrey_Incr", True, True, -1, 1) + rom.get_data(0xAD, 0xED9C, 0xEDAE, "uint16", kMotherBrain_TransitionToFromGrey_Decr, "kMotherBrain_TransitionToFromGrey_Decr", True, True, -1, 1) + rom.get_data(0xAD, 0xEF87, 0xEF99, "uint16", kMotherBrain_FadeToGray_Drained, "kMotherBrain_FadeToGray_Drained", True, True, -1, 1) + rom.get_data(0xAD, 0xF107, 0xF119, "uint16", kMotherBrain_FadeToGray_RealDeath, "kMotherBrain_FadeToGray_RealDeath", True, True, -1, 1) + rom.get_data(0xAD, 0xF273, 0xF283, "uint16", kMotherBrain_Phase3_TurnLightsBackOn, "kMotherBrain_Phase3_TurnLightsBackOn", True, True, -1, 1) + return + +get_AD() \ No newline at end of file diff --git a/Port_Extraction/bank_B2/extract_bank_B2.py b/Port_Extraction/bank_B2/extract_bank_B2.py new file mode 100644 index 0000000..6120d7e --- /dev/null +++ b/Port_Extraction/bank_B2/extract_bank_B2.py @@ -0,0 +1,19 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kWallSpacePirates_Palette_3 = [] +kSpacePirate_InstrListPtrs = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_B2(): + rom.get_data(0xB2, 0x8727, 0x8747, "uint16", kWallSpacePirates_Palette_3, "kWallSpacePirates_Palette_3", True, True, -1, 1) + rom.get_data(0xB2, 0xF959, 0xF969, "uint16", kSpacePirate_InstrListPtrs, "kSpacePirate_InstrListPtrs", True, True, 4, 1) + return + +get_B2() \ No newline at end of file diff --git a/Port_Extraction/bank_B3/extract_bank_B3.py b/Port_Extraction/bank_B3/extract_bank_B3.py new file mode 100644 index 0000000..5b5f54e --- /dev/null +++ b/Port_Extraction/bank_B3/extract_bank_B3.py @@ -0,0 +1,43 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kBrinstarRedPipeBug_InstrListPtrs = [] +kBrinstarGreenPipeBug_InstrListPtrs = [] +kBotwoon_HoleHitboxes = [] +kBotwoon_SpeedTable = [] +kBotwoon_9675PtrsUNUSED = [] +kBotwoonHealthThresForPalChange = [] +kBotwoonHealthBasedPalette = [] +kBotwoon_MouthClosedDirectionInstrListPtrs = [] +kBotwoon_SpitDirectionInstrListPtrs = [] +kEscapeEtecoon_XPositions = [] +kEscapeEtecoon_YPositions = [] +kEscapeEtecoon_InstrListPtrs = [] +kEscapeEtecoon_FuncPtrs = [] +kEscapeEtecoon_XVelocities = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_B3(): + rom.get_data(0xB3, 0x882B, 0x8833, "uint16", kBrinstarRedPipeBug_InstrListPtrs, "kBrinstarRedPipeBug_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xB3, 0x8833, 0x883B, "uint16", kBrinstarGreenPipeBug_InstrListPtrs, "kBrinstarGreenPipeBug_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xB3, 0x949B, 0x94BB, "uint16", kBotwoon_HoleHitboxes, "kBotwoon_HoleHitboxes", True, True, 4, 1) + rom.get_data(0xB3, 0x94BB, 0x94C7, "uint16", kBotwoon_SpeedTable, "kBotwoon_SpeedTable", False, True, 2, 1) + rom.get_data(0xB3, 0x9675, 0x967B, "uint16", kBotwoon_9675PtrsUNUSED, "kBotwoon_9675PtrsUNUSED", True, True, -1, 1) + rom.get_data(0xB3, 0x981B, 0x982B, "uint16", kBotwoonHealthThresForPalChange, "kBotwoonHealthThresForPalChange", True, True, -1, 1) + rom.get_data(0xB3, 0x971B, 0x981B, "uint16", kBotwoonHealthBasedPalette, "kBotwoonHealthBasedPalette", True, True, 16, 1) + rom.get_data(0xB3, 0x946B, 0x949B, "uint16", kBotwoon_MouthClosedDirectionInstrListPtrs, "kBotwoon_MouthClosedDirectionInstrListPtrs", True, True, 8, 1) + rom.get_data(0xB3, 0x948B, 0x949B, "uint16", kBotwoon_SpitDirectionInstrListPtrs, "kBotwoon_SpitDirectionInstrListPtrs", True, True, -1, 1) + rom.get_data(0xB3, 0xE718, 0xE71E, "uint16", kEscapeEtecoon_XPositions, "kEscapeEtecoon_XPositions", False, True, -1, 1) + rom.get_data(0xB3, 0xE71E, 0xE724, "uint16", kEscapeEtecoon_YPositions, "kEscapeEtecoon_YPositions", False, True, -1, 1) + rom.get_data(0xB3, 0xE72A, 0xE730, "uint16", kEscapeEtecoon_InstrListPtrs, "kEscapeEtecoon_InstrListPtrs", True, True, -1, 1) + rom.get_data(0xB3, 0xE724, 0xE72A, "uint16", kEscapeEtecoon_FuncPtrs, "kEscapeEtecoon_FuncPtrs", True, True, -1, 1) + rom.get_data(0xB3, 0xE730, 0xE736, "uint16", kEscapeEtecoon_XVelocities, "kEscapeEtecoon_XVelocities", True, True, -1, 1) + return + +get_B3() \ No newline at end of file diff --git a/Port_Extraction/bank_B4/extract_bank_B4.py b/Port_Extraction/bank_B4/extract_bank_B4.py new file mode 100644 index 0000000..d1898b5 --- /dev/null +++ b/Port_Extraction/bank_B4/extract_bank_B4.py @@ -0,0 +1,18 @@ +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import common_data as rom + +kSpriteObject_InstrListPtrs = [] + +#Format is as follows: +#rom.get_data(bank, starting address, ending address, "data type", array, "array name", hex bool, array bool, new line, new space) +#"hex bool" is whether you want the data in hexadecimal or in decimal format +#"array bool" is whether it's a single value or an array (will print [] if array, won't otherwise) +#"new line/space" is how many elements you want before you insert a new line/space, -1 is never +def get_B4(): + rom.get_data(0xB4, 0xBDA8, 0xBE24, "uint16", kSpriteObject_InstrListPtrs, "kSpriteObject_InstrListPtrs", True, True, 16, 1) + #rom.get_data(, 0x, "", , "", , , , ) + return + +get_B4() \ No newline at end of file diff --git a/Port_Extraction/common_data.py b/Port_Extraction/common_data.py new file mode 100644 index 0000000..fa20393 --- /dev/null +++ b/Port_Extraction/common_data.py @@ -0,0 +1,389 @@ +import sys + +class Rom: + def __init__(self): + self.data = open('sm.smc', 'rb').read() + + def map(self, addr): + assert addr & 0x8000 + return (((addr >> 16) << 15) | (addr & 0x7fff)) & 0x3fffff + + def get_byte(self, addr): + return self.data[self.map(addr)] + + def get_word(self, addr): + addr = self.map(addr) + return self.data[addr] + self.data[addr + 1] * 256 + + def get_long(self, addr): + addr = self.map(addr) + return self.data[addr] + self.data[addr + 1] * 256 + self.data[addr + 2] * 65536 + + def get_double(self, addr): + addr = self.map(addr) + return self.data[addr] + self.data[addr + 1] * 256 + self.data[addr + 2] * 65536 + self.data[addr + 3] * 16777216 + + def get_bytes(self, addr, n): + addr = self.map(addr) + return self.data[addr:addr+n] + +ROM = Rom() +get_byte = ROM.get_byte +get_word = ROM.get_word +get_long = ROM.get_long +get_double = ROM.get_double + + +class uint8: + def __init__(self, addr): + self.byte = get_byte(addr) + def __str__(self): + output = "" + if hex_flag == True: + output = "%4s" % hex(self.byte) + else: + #if self.byte >= 0x80: + #self.byte = -(self.byte ^ 0xFF) -1 + output = "%3s" % self.byte + return output + +class uint16: + def __init__(self, addr): + self.word = get_word(addr) + def __str__(self): + output = "" + if hex_flag == True: + output = "%6s" % hex(self.word) + else: + #if self.word >= 0x8000: + #self.word = -(self.word ^ 0xFFFF) -1 + output = "%5s" % self.word + return output + +class LongPtr: + def __init__(self, addr): + self.long_addr = get_word(addr) + self.bank = get_byte(addr+2) + def __str__(self): + output = "" + if hex_flag == True: + output = "%6s, %4s" % (hex(self.long_addr), hex(self.bank)) + else: + output = "%s, %s" % (self.long_addr, self.bank) + return output + +class uint32: + def __init__(self, addr): + self.double = get_double(addr) + def __str__(self): + output = "" + if hex_flag == True: + output = "%10s" % hex(self.double) + else: + output = "%10s" % self.double + return output + +class MapScrollArrowData: + def __init__(self, addr): + self.x_pos = get_word(addr) + self.y_pos = get_word(addr+2) + self.anim_id = get_word(addr+4) + self.input = get_word(addr+6) + self.map_scroll_dir = get_word(addr+8) + def __str__(self): + output = "%s, %s, %s, %s, %s, };" % (self.x_pos, self.y_pos, self.anim_id, self.input, self.map_scroll_dir) + return output + +class ExpandingSquareVels: + def __init__(self, addr): + self.left_subvel = get_word(addr) + self.left_vel = get_word(addr+2) + self.right_subvel = get_word(addr+4) + self.right_vel = get_word(addr+6) + self.top_subvel = get_word(addr+8) + self.top_vel = get_word(addr+10) + self.bottom_subvel = get_word(addr+12) + self.bottom_vel = get_word(addr+14) + def __str__(self): + output = "%6s,%6s, %6s,%3s, %6s,%6s, %6s,%3s, " % (hex(self.left_subvel), hex(self.left_vel), hex(self.right_subvel), hex(self.right_vel), + hex(self.top_subvel), hex(self.top_vel), hex(self.bottom_subvel), hex(self.bottom_vel)) + return output + +class PauseScreenSpriteAnimationData: + def __init__(self, addr): + self.unused_1 = get_word(addr) + self.lr_highlight = get_word(addr+2) + self.item_selector = get_word(addr+4) + self.unused_2 = get_word(addr+6) + self.unused_3 = get_word(addr+8) + self.map_scroll_arrow_up = get_word(addr+10) + self.map_scroll_arrow_down = get_word(addr+12) + self.map_scroll_arrow_right = get_word(addr+14) + self.map_scroll_arrow_left = get_word(addr+16) + def __str__(self): + output = "%6s, %6s, %6s, %6s, %6s, %6s, %6s, %6s, %6s, };" % (hex(self.unused_1), hex(self.lr_highlight), hex(self.item_selector), hex(self.unused_2), + hex(self.unused_3), hex(self.map_scroll_arrow_up), hex(self.map_scroll_arrow_down), + hex(self.map_scroll_arrow_right), hex(self.map_scroll_arrow_left),) + return output + +class FileCopyArrowStuff: + def __init__(self, addr): + self.spritemap_index = get_word(addr) + self.x_pos = get_word(addr+2) + self.y_pos = get_word(addr+4) + def __str__(self): + output = "%s, %s, %s, " % (self.spritemap_index, self.x_pos, self.y_pos) + return output + +class MsgBoxConfig: + def __init__(self, addr): + self.modify_box_func = get_word(addr) + self.draw_initial_tilemap = get_word(addr+2) + self.message_tilemap = get_word(addr+4) + def __str__(self): + output = "%6s, %6s, %6s, " % (hex(self.modify_box_func), hex(self.draw_initial_tilemap), hex(self.message_tilemap)) + return output + +class HdmaScrollEntry: + def __init__(self, addr): + self.top_pos = get_word(addr) + self.scroll_subspeed = get_word(addr+2) + self.scroll_speed = get_word(addr+4) + self.hdma_data_table_entry = get_word(addr+6) + def __str__(self): + output = "%6s, %6s, %6s, %6s" % (hex(self.top_pos), hex(self.scroll_subspeed), hex(self.scroll_speed), hex(self.hdma_data_table_entry)) + return output + +class XrayBlockData: + def __init__(self, addr): + self.value = get_word(addr) + self.addr = get_word(addr+2) + def __str__(self): + output = "%6s, %6s" % (hex(self.value), hex(self.addr)) + return output + +class SamusCrystalFlashPalTable: + def __init__(self, addr): + self.ptr = get_word(addr) + self.timer = get_word(addr+2) + def __str__(self): + output = "%6s,%s" % (hex(self.ptr), self.timer) + return output + +class ProjectileDamagesAndInstrPtr: + def __init__(self, addr): + self.damages = get_word(addr) + self.instr_ptr = get_word(addr+2) + def __str__(self): + output = "%6s, %6s" % (hex(self.damages), hex(self.instr_ptr)) + return output + +class GrappleBeamSpecialAngles: + def __init__(self, addr): + self.angle = get_word(addr) + self.pose = get_word(addr+2) + self.x_offset = get_word(addr+4) + self.y_offset = get_word(addr+6) + self.grapple_function = get_word(addr+8) + def __str__(self): + output = "%6s, %6s, %6s, %6s, %6s" % (hex(self.angle), hex(self.pose), hex(self.x_offset), hex(self.y_offset), hex(self.grapple_function)) + return output + +class MaridiaSnailData2: + def __init__(self, addr): + self.field_0 = get_word(addr) + self.field_2 = get_word(addr+2) + self.field_4 = get_word(addr+4) + self.field_6 = get_word(addr+6) + def __str__(self): + output = "%6s, %5s, %6s, %5s" % (hex(self.field_0), self.field_2, hex(self.field_4), self.field_6) + return output + +class KraidInstrList: + def __init__(self, addr): + self.timer = get_word(addr) + self.tilemap = get_word(addr+2) + self.vuln_mouth_hitbox = get_word(addr+4) + self.invuln_mouth_hitbox = get_word(addr+6) + def __str__(self): + output = "%5s, %6s, %6s, %6s" % (self.timer, hex(self.tilemap), hex(self.vuln_mouth_hitbox), hex(self.invuln_mouth_hitbox)) + return output + +class Hitbox: + def __init__(self, addr): + self.left = get_word(addr) + self.top = get_word(addr+2) + self.right = get_word(addr+4) + self.bottom = get_word(addr+6) + self.samus_coll_ptr = get_word(addr+8) + self.proj_coll_ptr = get_word(addr+10) + def __str__(self): + output = "%6s, %6s, %6s, %6s, %6s, %6s" % (hex(self.left), hex(self.top), hex(self.right), hex(self.bottom), + hex(self.samus_coll_ptr), hex(self.proj_coll_ptr)) + return output + +class SpriteDrawInstr: + def __init__(self, addr): + self.timer = get_word(addr) + self.sprite_ptr = get_word(addr+2) + def __str__(self): + output = "%5s, %6s" % (self.timer, hex(self.sprite_ptr)) + return output + +class KraidSinkTable: + def __init__(self, addr): + self.kraid_y_pos = get_word(addr) + self.vram_bg2_tilemap_offset = get_word(addr+2) + self.func_ptr = get_word(addr+4) + def __str__(self): + output = "%6s, %6s, %6s" % (hex(self.kraid_y_pos), hex(self.vram_bg2_tilemap_offset), hex(self.func_ptr)) + return output + +class ExtendedSpriteMap: + def __init__(self, addr): + self.xpos = get_word(addr) + self.ypos = get_word(addr+2) + self.spritemap = get_word(addr+4) + self.hitbox_ptr_ = get_word(addr+6) + def __str__(self): + output = "%6s, %6s, %6s, %6s" % (hex(self.xpos), hex(self.ypos), hex(self.spritemap), hex(self.hitbox_ptr_)) + return output + +hex_flag = False +array_flag = False + +def get_data(bank, start, end, type, data, name, hexadecimal, array, new_line, new_space): + global hex_flag, array_flag + hex_flag = hexadecimal + array_flag = array + data_address = (bank << 16) + start + end_address = (bank << 16) + end + while data_address < end_address: + new_data = 0 + if type == "uint8": + new_data = uint8(data_address) + data_address += 1 + + elif type == "uint16": + new_data = uint16(data_address) + data_address += 2 + + elif type == "LongPtr": + new_data = LongPtr(data_address) + data_address += 3 + + elif type == "uint32": + new_data = uint32(data_address) + data_address += 4 + + elif type == "MapScrollArrowData": + new_data = MapScrollArrowData(data_address) + data_address += 10 + + elif type == "ExpandingSquareVels": + new_data = ExpandingSquareVels(data_address) + data_address += 16 + + elif type == "PauseScreenSpriteAnimationData": + new_data = PauseScreenSpriteAnimationData(data_address) + data_address += 18 + + elif type == "HdmaScrollEntry": + new_data = HdmaScrollEntry(data_address) + data_address += 8 + if data_address > end_address: + data_address -= 6 + new_data = uint16(data_address) + data.append(new_data) + break + + elif type == "XrayBlockData": + new_data = XrayBlockData(data_address) + data_address += 4 + if data_address > end_address: + data_address -= 2 + new_data = uint16(data_address) + data.append(new_data) + break + + elif type == "SamusCrystalFlashPalTable": + new_data = SamusCrystalFlashPalTable(data_address) + data_address += 4 + + elif type == "ProjectileDamagesAndInstrPtr": + new_data = ProjectileDamagesAndInstrPtr(data_address) + data_address += 4 + + elif type == "GrappleBeamSpecialAngles": + new_data = GrappleBeamSpecialAngles(data_address) + data_address += 10 + + elif type == "MaridiaSnailData2": + new_data = MaridiaSnailData2(data_address) + data_address += 8 + + elif type == "KraidInstrList": + new_data = KraidInstrList(data_address) + data_address += 8 + if data_address > end_address: + data_address -= 8 + new_data = uint16(data_address) + data.append(new_data) + break + + elif type == "Hitbox": + new_data = Hitbox(data_address) + data_address += 12 + + elif type == "SpriteDrawInstr": + new_data = SpriteDrawInstr(data_address) + data_address += 4 + + elif type == "KraidSinkTable": + new_data = KraidSinkTable(data_address) + data_address += 6 + if data_address > end_address: + data_address -= 6 + new_data = uint16(data_address) + data.append(new_data) + break + + elif type == "ExtendedSpriteMap": + new_data = ExtendedSpriteMap(data_address) + data_address += 8 + + data.append(new_data) + + print_data(type, data, name, new_line, new_space) + return + + +def print_data(type, data, name, new_line, new_space): + #print(data type + " " + name + "[] = { \n\t") + #print("%s %s[] = {" % (type, name), end="\n ") + print("%s %s" % (type, name), end="") + if array_flag == True: + print("[] = {", end="\n ") + elif array_flag == False: + print(" = {", end=" ") + new_space_counter = 0 + new_line_counter = 0 + for entry in data: + if new_space_counter == new_space: + print(end=" ") + new_space_counter = 0 + + if new_line_counter == new_line: + print(end="\n ") + new_line_counter = 0 + + print(entry, end=",") + new_space_counter += 1 + new_line_counter += 1 + + if array_flag == True: + print("\n};\n") + elif array_flag == False: + print(" };\n") + return + diff --git a/Port_Extraction/out_92_original.txt b/Port_Extraction/out_92_original.txt new file mode 100644 index 0000000000000000000000000000000000000000..220285d7182a66ce53f0f60ef7755ad34a092ad8 GIT binary patch literal 316804 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