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 0000000..220285d Binary files /dev/null and b/Port_Extraction/out_92_original.txt differ diff --git a/README.md b/README.md index 4e9dc03..d6efe53 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,17 @@ # sm -Our discord server is: https://discord.gg/AJJbJAzNNJ +The building instructions are the same as the original port. For more information about the original port, see: https://github.com/snesrev/sm. -Early version. It has bugs and the code is messy. +This is a fork of the Super Metroid PC Port meant to continue the work and add more features. There are various goals intended for this project, including: +1. Giving all functions and variables proper names. (work has been made on functions, but not on variables as of yet) +2. Removing all the calls to read code directly from rom. (some progress has been made removing RomPtrs, but much more work is to be done) +3. Adding MSU-1 support. (early support has been added, but is not perfect and currently disables mismatch checking) +4. Adding widescreen and overscan support. (no work yet) -For building instructions, see: https://github.com/snesrev/sm/blob/main/BUILDING.md +The fork is still very early in development and there is much to be done. Outside of early MSU-1 support, there is not much improvement on the player side. +Any contributions, even as simple as giving a function or a variable a proper name, is welcome. The bank logs are a great resource for this: https://patrickjohnston.org/bank/. -Put sm.smc (sha1 hash da957f0d63d14cb441d215462904c4fa8519c613) in the root folder. When running, it will run both versions and compare frame by frame. If it detects a mismatch, it saves a snapshot in saves/ and displays a counter on screen counting down from 300. +Note about Port_Extraction folder: +Port_Extraction is currently a scratchpad to manually extract assets from the rom and insert them into the port. +In the long run, this will be used to automatically extract all necessary assets from the game.