dump in pokered/extras/ python stuff from b185b245

1 files changed, 702 insertions, 0 deletions

diff --git a/redtools/extract_maps.py b/redtools/extract_maps.py
new file mode 100644
index 0000000..bc0a193
--- /dev/null
+++ b/redtools/extract_maps.py
@@ -0,0 +1,702 @@
+#author: Bryan Bishop <kanzure@gmail.com>
+#date: 2012-01-02
+#url: http://hax.iimarck.us/files/rbheaders.txt
+import json
+
+#parse hex values as base 16 (see calculate_pointer)
+base = 16
+
+#where to load the rom from
+rom_filename = "../baserom.gbc"
+rom = None #load the rom later
+
+#map header pointers start at 0x1AE
+start_map_header_pointers = 0x1AE
+
+#bank bytes for each map header start at 0xC23D
+start_map_header_pointer_banks = 0xC23D
+
+#number of maps in this list
+map_count = 0xF8 #including the 0th the total is is 248 or 0xF8
+
+bad_maps = [0x0b, 0x45, 0x4b, 0x4e, 0x69, 0x6a, 0x6b, 0x6d, 0x6e, 0x6f, 0x70, 0x72, 0x73, 0x74, 0x75, 0xad, 0xcc, 0xcd, 0xce, 0xe7, 0xed, 0xee, 0xf1, 0xf2, 0xf3, 0xf4]
+
+maps = {
+         0x00: "Pallet Town",
+         0x01: "Viridian City",
+         0x02: "Pewter City",
+         0x03: "Cerulean City",
+         0x04: "Lavender Town", #??
+         0x05: "Vermilion City", #correct
+         0x06: "Celadon City",
+         0x07: "Fuchsia City",
+         0x08: "Cinnabar Island",
+         0x09: "Indigo Plateau",
+         0x0A: "Saffron City",
+         0x0B: "FREEZE",
+         0x0C: "Route 1",
+         0x0D: "Route 2",
+         0x0E: "Route 3",
+         0x0F: "Route 4",
+         0x10: "Route 5",
+         0x11: "Route 6",
+         0x12: "Route 7",
+         0x13: "Route 8",
+         0x14: "Route 9",
+         0x15: "Route 10",
+         0x16: "Route 11",
+         0x17: "Route 12",
+         0x18: "Route 13",
+         0x19: "Route 14",
+         0x1A: "Route 15",
+         0x1B: "Route 16",
+         0x1C: "Route 17",
+         0x1D: "Route 18",
+         0x1E: "Route 19",
+         0x1F: "Route 20",
+         0x20: "Route 21",
+         0x21: "Route 22",
+         0x22: "Route 23",
+         0x23: "Route 24",
+         0x24: "Route 25",
+         0x25: "Red's House 1F",
+         0x26: "Red's House 2F",
+         0x27: "Blue's House",
+         0x28: "Oak's Lab",
+         0x29: "Viridian Poke Center",
+         0x2A: "Viridian Mart",
+         0x2B: "School",
+         0x2C: "Viridian House",
+         0x2D: "Viridian Gym",
+         0x2E: "Digletts Cave (Route 2)",
+         0x2F: "Viridian Forest (exit)",
+         0x30: "Route 2 House",
+         0x31: "Route 2 Gate",
+         0x32: "Viridian Forest (Entrance)",
+         0x33: "Viridian Forest",
+         0x34: "Museum F1",
+         0x35: "Museum F2",
+         0x36: "Pewter Gym",
+         0x37: "Pewter House (1)",
+         0x38: "Pewter Mart",
+         0x39: "Pewter House (2)",
+         0x3A: "Pewter Pokecenter",
+         0x3B: "Mt. Moon (1)",
+         0x3C: "Mt. Moon (2)",
+         0x3D: "Mt. Moon (3)",
+         0x3E: "Cerulean House (Trashed)",
+         0x3F: "Cerulean House (2)",
+         0x40: "Cerulean Pokecenter",
+         0x41: "Cerulean Gym",
+         0x42: "Bike Shop",
+         0x43: "Cerulean Mart",
+         0x44: "Mt. Moon Pokecenter",
+         0x45: "COPY OF: Trashed House",
+         0x46: "Route 5 Gate",
+         0x47: "Underground Tunnel Entrance (Route 5)",
+         0x48: "Day Care M",
+         0x49: "Route 6 Gate",
+         0x4A: "Underground Tunnel Entrance (Route 6)",
+         0x4B: "COPY OF: Underground Tunnel Entrance (Route 6)",
+         0x4C: "Route 7 Gate",
+         0x4D: "Underground Path Entrance (Route 7)",
+         0x4E: "COPY OF: Underground Path Entrance (Route 7)",
+         0x4F: "Route 8 Gate",
+         0x50: "Underground Path Entrance (Route 8)",
+         0x51: "Rock Tunnel Pokecenter",
+         0x52: "Rock Tunnel (1)",
+         0x53: "Power Plant",
+         0x54: "Route 11 Gate",
+         0x55: "Digletts Cave Entrance (Route 11)",
+         0x56: "Route 11 Gate (Upstairs)",
+         0x57: "Route 12 Gate",
+         0x58: "Bill's House",
+         0x59: "Vermilion Pokecenter",
+         0x5A: "Fan Club",
+         0x5B: "Vermilion Mart",
+         0x5C: "Vermilion Gym",
+         0x5D: "Vermilion House (1)",
+         0x5E: "Vermilion Dock",
+         0x5F: "S.S. Anne (1)",
+         0x60: "S.S. Anne (2)",
+         0x61: "S.S. Anne (3)",
+         0x62: "S.S. Anne (4)",
+         0x63: "S.S. Anne (5)",
+         0x64: "S.S. Anne (6)",
+         0x65: "S.S. Anne (7)",
+         0x66: "S.S. Anne (8)",
+         0x67: "S.S. Anne (9)",
+         0x68: "S.S. Anne (10)",
+         0x69: "FREEZE",
+         0x6A: "FREEZE",
+         0x6B: "FREEZE",
+         0x6C: "Victory Road (1)",
+         0x6D: "FREEZE",
+         0x6E: "FREEZE",
+         0x6F: "FREEZE",
+         0x70: "FREEZE",
+         0x71: "Lance",
+         0x72: "FREEZE",
+         0x73: "FREEZE",
+         0x74: "FREEZE",
+         0x75: "FREEZE",
+         0x76: "Hall of Fame Room",
+         0x77: "Underground Path (N/S)",
+         0x78: "Gary",
+         0x79: "Underground Path (W/E)",
+         0x7A: "Celadon Mart (1)",
+         0x7B: "Celadon Mart (2)",
+         0x7C: "Celadon Mart (3)",
+         0x7D: "Celadon Mart (4)",
+         0x7E: "Celadon Mart Roof",
+         0x7F: "Celadon Mart Elevator",
+         0x80: "Celadon Mansion (1)",
+         0x81: "Celadon Mansion (2)",
+         0x82: "Celadon Mansion (3)",
+         0x83: "Celadon Mansion (4)",
+         0x84: "Celadon Mansion (5)",
+         0x85: "Celadon Pokecenter",
+         0x86: "Celadon Gym",
+         0x87: "Celadon Game Corner",
+         0x88: "Celadon Mart 5",
+         0x89: "Celadon Prize Room",
+         0x8A: "Celadon Diner",
+         0x8B: "Celadon House",
+         0x8C: "Celadon Hotel",
+         0x8D: "Lavender Pokecenter",
+         0x8E: "Pokemon Tower (1)",
+         0x8F: "Pokemon Tower (2)",
+         0x90: "Pokemon Tower (3)",
+         0x91: "Pokemon Tower (4)",
+         0x92: "Pokemon Tower (5)",
+         0x93: "Pokemon Tower (6) ",
+         0x94: "Pokemon Tower (7)",
+         0x95: "Lavender House (1)",
+         0x96: "Lavender Mart",
+         0x97: "Lavender House (2)",
+         0x98: "Fuchsia Mart",
+         0x99: "Fuchsia House (1)",
+         0x9A: "Fuchsia Pokecenter",
+         0x9B: "Fuchsia House (2)",
+         0x9C: "Safari Zone Entrance",
+         0x9D: "Fuchsia Gym",
+         0x9E: "Fuchsia Meeting Room",
+         0x9F: "Seafoam Islands (2)",
+         0xA0: "Seafoam Islands (3)",
+         0xA1: "Seafoam Islands (4)",
+         0xA2: "Seafoam Islands (5)",
+         0xA3: "Vermilion House (2)",
+         0xA4: "Fuchsia House (3)",
+         0xA5: "Mansion (1)",
+         0xA6: "Cinnabar Gym",
+         0xA7: "Lab (1)",
+         0xA8: "Lab (2)",
+         0xA9: "Lab (3)",
+         0xAA: "Lab (4)",
+         0xAB: "Cinnabar Pokecenter",
+         0xAC: "Cinnabar Mart",
+         0xAD: "COPY: Cinnabar Mart",
+         0xAE: "Indigo Plateau Lobby",
+         0xAF: "Copycat's House F1",
+         0xB0: "Copycat's House F2",
+         0xB1: "Fighting Dojo",
+         0xB2: "Saffron Gym",
+         0xB3: "Saffron House (1)",
+         0xB4: "Saffron Mart",
+         0xB5: "Silph Co (1)",
+         0xB6: "Saffron Pokecenter",
+         0xB7: "Saffron House (2)",
+         0xB8: "Route 15 Gate",
+         0xBA: "Route 16 Gate Map",
+         0xBB: "Route 16 Gate Upstairs",
+         0xBC: "Route 16 House",
+         0xBD: "Route 12 House",
+         0xBE: "Route 18 Gate",
+         0xBF: "Route 18 Gate Header",
+         0xC0: "Seafoam Islands (1)",
+         0xC1: "Route 22 Gate",
+         0xC2: "Victory Road (2)",
+         0xC3: "Route 12 Gate Upstairs",
+         0xC4: "Vermilion House (3)",
+         0xC5: "Diglett's Cave",
+         0xC6: "Victory Road (3)",
+         0xC7: "Rocket Hideout (1)",
+         0xC8: "Rocket Hideout (2)",
+         0xC9: "Rocket Hideout (3)",
+         0xCA: "Rocket Hideout (4) ",
+         0xCB: "Rocket Hideout (Elevator)",
+         0xCC: "FREEZE",
+         0xCD: "FREEZE",
+         0xCE: "FREEZE",
+         0xCF: "Silph Co (2)",
+         0xD0: "Silph Co (3)",
+         0xD1: "Silph Co (4)",
+         0xD2: "Silph Co (5)",
+         0xD3: "Silph Co (6)",
+         0xD4: "Silph Co (7)",
+         0xD5: "Silph Co (8)",
+         0xD6: "Mansion (2)",
+         0xD7: "Mansion (3)",
+         0xD8: "Mansion (4)",
+         0xD9: "Safari Zone East",
+         0xDA: "Safari Zone North",
+         0xDB: "Safari Zone West",
+         0xDC: "Safari Zone Center",
+         0xDD: "Safari Zone Rest House (1)",
+         0xDE: "Safari Zone Secret House",
+         0xDF: "Safari Zone Rest House (2)",
+         0xE0: "Safari Zone Rest House (3)",
+         0xE1: "Safari Zone Rest House (4)",
+         0xE2: "Unknown Dungeon (2)",
+         0xE3: "Unknown Dungeon (3)",
+         0xE4: "Unknown Dungeon (1)",
+         0xE5: "Name Rater",
+         0xE6: "Cerulean House (3)",
+         0xE7: "FREEZE",
+         0xE8: "Rock Tunnel (2)",
+         0xE9: "Silph Co (9)",
+         0xEA: "Silph Co (10)",
+         0xEB: "Silph Co (11)",
+         0xEC: "Silph Co (Elevator)",
+         0xED: "FREEZE",
+         0xEE: "FREEZE",
+         0xEF: "Battle Center M",
+         0xF0: "Trade Center M",
+         0xF1: "FREEZE",
+         0xF2: "FREEZE",
+         0xF3: "FREEZE",
+         0xF4: "FREEZE",
+         0xF5: "Lorelei",
+         0xF6: "Bruno",
+         0xF7: "Agatha"
+       }
+
+map_pointers = {
+    #0x00: {
+    #       "name": "Pallet Town",
+    #       "address": 0x182a1
+    #      },
+               }
+
+map_headers = {
+    #0x00: {
+    #       "name": "Pallet Town",
+    #       "address": 0x182a1,
+    #       "tileset"
+    #       "y"
+    #       "x"
+    #       "map_pointer"
+    #       "texts_pointer"
+    #       "script_pointer"
+    #       "connection_byte"
+    #       "num_connections"
+    #       "connections":
+    #        { "0":
+    #          { map_id, connected_map_tile_pointer, current_map_tile_pointer, bigness, width, y, x, window_pointer }
+    #        },
+    #       "object_data_pointer"
+    #      },
+              }
+
+#haters gonna hate
+def load_rom(filename=None):
+    "load the rom into a global (returns True/False)"
+    global rom
+
+    if not filename:
+        filename = rom_filename
+
+    try:
+        rom = open(filename, "rb").read()
+        return True
+    except Exception, exception:
+        print "error loading rom"
+        return False
+
+def assert_rom():
+    global rom
+    assert rom, "rom must be loaded, see load_rom()"
+
+def calculate_pointer(short_pointer, bank):
+    short_pointer = int(short_pointer)
+    bank = int(bank)
+
+    pointer = short_pointer - 0x4000 + (bank * 0x4000)
+
+    #result will be an integer
+    return pointer
+
+def get_nth_map_header_pointer_bank_byte_address(map_id):
+    "returns the address to the bank byte associated with this map pointer"
+    address = start_map_header_pointer_banks + map_id
+    return address
+
+def get_nth_map_header_pointer_bank_byte(map_id):
+    "returns the bank number for this map header"
+    assert_rom()
+
+    address = get_nth_map_header_pointer_bank_byte_address(map_id)
+    bank_byte = ord(rom[address])
+    return bank_byte
+
+def get_nth_map_header_pointer(map_id):
+    "returns the full pointer to the map header struct for this map"
+    assert_rom()
+
+    #figure out where the bytes for this pointer are located
+    byte1_address = start_map_header_pointers + (map_id * 2)
+    byte2_address = start_map_header_pointers + (map_id * 2) + 1
+
+    #grab the two bytes making up the partial pointer
+    byte1 = ord(rom[byte1_address])
+    byte2 = ord(rom[byte2_address])
+
+    #swap the bytes (16-bit pointers for z80 are little endian)
+    temp = byte1
+    byte1 = byte2
+    byte2 = temp
+    del temp
+
+    #combine these into a single pointer (0x byte1 byte2)
+    partial_pointer = (byte2 + (byte1 << 8))
+    #print hex(partial_pointer)
+
+    #get the bank id
+    bank = get_nth_map_header_pointer_bank_byte(map_id)
+
+    #calculate the full pointer
+    pointer = calculate_pointer(partial_pointer, bank)
+
+    #return it as an integer
+    return pointer
+
+def load_map_pointers():
+    global maps
+    global map_pointers
+
+    for map in maps.keys():
+        pointer = get_nth_map_header_pointer(map)
+        #print maps[map] + "\t\t\t" + hex(pointer)
+
+        entry = {
+                "name": maps[map],
+                "address": hex(pointer),
+                "bank": hex(get_nth_map_header_pointer_bank_byte(map))
+                }
+        map_pointers[map] = entry
+    
+    #print json.dumps(map_pointers)
+
+def read_connection_bytes(connection_bytes, bank):
+    map_id = ord(connection_bytes[0])
+    
+    #connection strip
+    connected_map_tile_pointer_byte1 = ord(connection_bytes[1])
+    connected_map_tile_pointer_byte2 = ord(connection_bytes[2])
+    connected_map_tile_pointer = (connected_map_tile_pointer_byte1 + (connected_map_tile_pointer_byte2 << 8))
+
+    #connection strip
+    current_map_tile_pointer_byte1 = ord(connection_bytes[3])
+    current_map_tile_pointer_byte2 = ord(connection_bytes[4])
+    current_map_tile_pointer = (current_map_tile_pointer_byte1 + (current_map_tile_pointer_byte2 << 8))
+
+    bigness_byte = ord(connection_bytes[5])
+    width_byte = ord(connection_bytes[6])
+    y = ord(connection_bytes[7])
+    x = ord(connection_bytes[8])
+
+    #window
+    window_pointer_byte1 = ord(connection_bytes[9])
+    window_pointer_byte2 = ord(connection_bytes[10])
+    window_pointer = (window_pointer_byte1 + (window_pointer_byte2 << 8))
+
+    connection_data = {
+                      "map_id": map_id,
+                      "connected_map_tile_pointer": hex(connected_map_tile_pointer),
+                      "current_map_tile_pointer": hex(current_map_tile_pointer),
+                      "bigness": hex(bigness_byte),
+                      "width": hex(width_byte),
+                      "y": y,
+                      "x": x,
+                      "window_pointer": hex(window_pointer),
+                      }
+    return connection_data
+
+def read_warp_data(address, warp_count):
+    warps = {}
+    for warp_id in range(0, warp_count):
+        offset = address + (warp_id*4) #4 bytes per warp
+        warp = {}
+        
+        warp["y"] = ord(rom[offset])
+        warp["x"] = ord(rom[offset+1])
+        warp["warp_to_point"] = ord(rom[offset+2])
+        warp["warp_to_map_id"] = ord(rom[offset+3])
+
+        warps[warp_id] = warp
+    return warps
+
+def read_sign_data(address, sign_count):
+    signs = {}
+    for sign_id in range(0, sign_count):
+        offset = address + (sign_id * 3)
+        sign = {}
+        sign["y"] = ord(rom[offset])
+        sign["x"] = ord(rom[offset+1])
+        sign["text_id"] = ord(rom[offset+2])
+        signs[sign_id] = sign
+    return signs
+
+def read_warp_tos(address, warp_count):
+    warp_tos = {}
+    for warp_to_id in range(0, warp_count):
+        offset = address + (warp_to_id * 4)
+        warp_to = {}
+        warp_to["event_displacement"] = [ord(rom[offset]),ord(rom[offset+1])]
+        warp_to["y"] = ord(rom[offset+2])
+        warp_to["x"] = ord(rom[offset+3])
+        warp_tos[warp_to_id] = warp_to
+    return warp_tos
+
+def get_object_data(address):
+    if type(address) == str: address = int(address, base)
+    output = {}
+
+    maps_border_tile = ord(rom[address])
+    
+    number_of_warps = ord(rom[address+1])
+    if number_of_warps == 0: warps = {}
+    else:
+        warps = read_warp_data(address+2, number_of_warps)
+
+    offset = number_of_warps * 4
+    address = address + 2 + offset
+
+    number_of_signs = ord(rom[address])
+    if number_of_signs == 0: signs = {}
+    else:
+        signs = read_sign_data(address+1, number_of_signs)
+
+    offset = number_of_signs * 3
+    address = address + 1 + offset
+
+    number_of_things = ord(rom[address])
+    address = address + 1
+
+    things = {}
+    for thing_id in range(0, number_of_things):
+        thing = {}
+        picture_number = ord(rom[address])
+        y = ord(rom[address+1])
+        x = ord(rom[address+2])
+        movement1 = ord(rom[address+3])
+        movement2 = ord(rom[address+4])
+        text_string_number = ord(rom[address+5])
+
+        address += 5 + 1
+
+        if text_string_number & (1 << 6) != 0: #trainer
+            thing["type"] = "trainer"
+            thing["trainer_type"] = ord(rom[address])
+            thing["pokemon_set"] = ord(rom[address+1])
+            address += 2
+        elif text_string_number & (1 << 7) != 0: #item
+            thing["type"] = "item"
+            thing["item_number"] = ord(rom[address])
+            address += 1
+        else: #normal person
+            thing["type"] = "person"
+
+        thing["picture_number"] = picture_number
+        thing["y"] = y
+        thing["x"] = x
+        thing["movement1"] = movement1
+        thing["movement2"] = movement2
+        thing["original_text_string_number"] = text_string_number
+        thing["text_string_number"] = text_string_number & 0xF
+        things[thing_id] = thing
+
+    warp_tos = read_warp_tos(address, number_of_warps)
+
+    output["maps_border_tile"] = maps_border_tile
+    output["number_of_warps"] = number_of_warps
+    output["warps"] = warps
+    output["number_of_signs"] = number_of_signs
+    output["signs"] = signs
+    output["number_of_things"] = number_of_things
+    output["things"] = things
+    output["warp_tos"] = warp_tos
+
+    return output
+
+def compute_object_data_size(object):
+    size = 4
+    size += 6 * (int(object["number_of_things"]))
+    
+    trainer_count = 0
+    item_count = 0
+    for thing in object["things"]:
+        thing = object["things"][thing]
+        if thing["type"] == "trainer": trainer_count += 1
+        elif thing["type"] == "item": item_count += 1
+    
+    size += 2 * trainer_count
+    size += item_count
+
+    size += 8 * object["number_of_warps"]
+    size += 3 * object["number_of_signs"]
+
+    return size
+
+def get_direction(connection_byte, connection_id):
+    """given a connection byte and a connection id, which direction is this connection?
+    the 0th connection of $5 is SOUTH and the 1st connection is EAST"""
+    connection_options = [0b1000, 0b0100, 0b0010, 0b0001]
+    results = ["NORTH", "SOUTH", "WEST", "EAST"]
+    for option in connection_options:
+        if (option & connection_byte) == 0:
+            results[connection_options.index(option)] = ""
+    #prune results
+    while "" in results:
+        results.remove("")
+    return results[connection_id]
+
+def read_map_header(address, bank):
+    address = int(address, base)
+    bank = int(bank, base)
+
+    tileset = ord(rom[address])
+    y = ord(rom[address+1])
+    x = ord(rom[address+2])
+
+    map_pointer_byte1 = ord(rom[address+3])
+    map_pointer_byte2 = ord(rom[address+4])
+    partial_map_pointer = (map_pointer_byte1 + (map_pointer_byte2 << 8))
+    map_pointer = calculate_pointer(partial_map_pointer, bank)
+
+    texts_pointer_byte1 = ord(rom[address+5])
+    texts_pointer_byte2 = ord(rom[address+6])
+    partial_texts_pointer = (texts_pointer_byte1 + (texts_pointer_byte2 << 8))
+    texts_pointer = calculate_pointer(partial_texts_pointer, bank)
+
+    script_pointer_byte1 = ord(rom[address+7])
+    script_pointer_byte2 = ord(rom[address+8])
+    partial_script_pointer = (script_pointer_byte1 + ( script_pointer_byte2 << 8))
+    script_pointer = calculate_pointer(partial_script_pointer, bank)
+
+    connection_byte = ord(rom[address+9]) #0xc = NORTH | SOUTH
+    # <&IIMarckus> the connection byte is a bitmask allowing 0-4 connections
+    # <&IIMarckus> each connection is 11 bytes
+    # <&IIMarckus> or'd
+    # <&IIMarckus> east = 1, west = 2, south = 4, north = 8
+    # <&IIMarckus> so a connection byte of 0xc means north/south
+    # <&IIMarckus> which means there are 22 more bytes, 11 for each connection
+    # < kanzure> 4 | 8 = c?
+    # <&IIMarckus> yes
+    # <&IIMarckus> easier to see if you convert to binary
+    # <&IIMarckus> 0100 | 1000 = 1100
+
+    num_connections = 0
+    connection_value = bin(connection_byte)[2:]
+    if connection_value[0] == "1": #NORTH
+        num_connections += 1
+    if len(connection_value) > 1 and connection_value[1] == "1": #SOUTH
+        num_connections += 1
+    if len(connection_value) > 2 and connection_value[2] == "1": #WEST
+        num_connections += 1
+    if len(connection_value) > 3 and connection_value[3] == "1": #EAST
+        num_connections += 1
+ 
+    #quick test for connection data
+    #connection0_stuff = rom[(address + 10):(address + 10 + 11)]
+    #print "Route: " + hex(ord(connection0_stuff[0]))
+
+    #setup
+    connections = {}
+
+    #go straight to object data if there are no connections
+    if num_connections > 0:
+        for connection in range(0, num_connections):
+            base_connection_address = address + 10 + (11 * connection)
+            connection_bytes = rom[base_connection_address : base_connection_address + 11]
+            connection_data = read_connection_bytes(connection_bytes, bank)
+            connection_data["direction"] = get_direction(connection_byte, connection)
+
+            connections[connection] = connection_data
+
+    #we might have to jump around a bit
+    offset = address + 10 + (11 * num_connections)
+
+    #object data
+    object_data_pointer_byte1 = ord(rom[offset])
+    object_data_pointer_byte2 = ord(rom[offset+1])
+    partial_object_data_pointer = (object_data_pointer_byte1 + (object_data_pointer_byte2 << 8))
+    object_data_pointer = calculate_pointer(partial_object_data_pointer, bank)
+    object_data = get_object_data(object_data_pointer)
+
+    texts = set()
+    for thing_id in object_data["things"].keys():
+        thing = object_data["things"][thing_id]
+        texts.add(thing["text_string_number"])
+    for sign_id in object_data["signs"].keys():
+        sign = object_data["signs"][sign_id]
+        texts.add(sign["text_id"])
+    texts = list(texts)
+    number_of_referenced_texts = len(texts)
+
+    map_header = {
+                 "tileset": hex(tileset),
+                 "y": hex(y),
+                 "x": hex(x),
+                 "map_pointer": hex(map_pointer),
+                 "texts_pointer": hex(texts_pointer),
+                 "number_of_referenced_texts": number_of_referenced_texts,
+                 "referenced_texts": texts,
+                 "script_pointer": hex(script_pointer),
+                 "connection_byte": hex(connection_byte),
+                 "num_connections": str(num_connections),
+                 "connections": connections, #NORTH, SOUTH, WEST, EAST order matters
+                 "object_data_pointer": hex(object_data_pointer),
+                 "object_data": object_data,
+                 }
+    return map_header
+
+def read_all_map_headers():
+    if rom == None: load_rom()
+    assert_rom()
+    if len(map_pointers) == 0: load_map_pointers()
+
+    for map_id in map_pointers.keys():
+        if map_id in bad_maps: continue
+        map2 = map_pointers[map_id]
+        map_header = read_map_header(map2["address"], map2["bank"])
+
+        map_header["id"] = map_id
+        map_header["name"] = map2["name"]
+        map_header["address"] = map2["address"]
+        map_header["bank"] = map2["bank"]
+
+        map_headers[map_id] = map_header
+    
+    return map_headers
+
+if __name__ == "__main__":
+    #read binary data from file
+    load_rom()
+    
+    #where are the map structs?
+    load_map_pointers()
+    #print json.dumps(map_pointers)
+
+    #experimental...
+    #print json.dumps(read_map_header(map_pointers[0]["address"], map_pointers[0]["bank"]))
+
+    read_all_map_headers()
+    #print json.dumps(map_headers)
+
+    #print map_headers[37]
+
+    for header in map_headers:
+        if header in bad_maps: continue
+        print "map " + str(header) + " has " + str(map_headers[header]["number_of_referenced_texts"]) + " referenced texts"
+