move old parsers from 'crystal' into crystalparts/

2 files changed, 425 insertions, 412 deletions

diff --git a/pokemontools/crystal.py b/pokemontools/crystal.py
index d5a861f..0222f8e 100644
--- a/pokemontools/crystal.py
+++ b/pokemontools/crystal.py
@@ -3022,25 +3022,6 @@ def parse_warps(address, warp_count, bank=None, map_group=None, map_id=None, deb
     all_warps.extend(warps)
     return warps
 
-def old_parse_warp_bytes(some_bytes, debug=True):
-    """parse some number of warps from the data"""
-    assert len(some_bytes) % warp_byte_size == 0, "wrong number of bytes"
-    warps = []
-    for bytes in helpers.grouper(some_bytes, count=warp_byte_size):
-        y = int(bytes[0], 16)
-        x = int(bytes[1], 16)
-        warp_to = int(bytes[2], 16)
-        map_group = int(bytes[3], 16)
-        map_id = int(bytes[4], 16)
-        warps.append({
-            "y": y,
-            "x": x,
-            "warp_to": warp_to,
-            "map_group": map_group,
-            "map_id": map_id,
-        })
-    return warps
-
 class XYTrigger(Command):
     size = trigger_byte_size
     macro_name = "xy_trigger"
@@ -4432,73 +4413,6 @@ def parse_signposts(address, signpost_count, bank=None, map_group=None, map_id=N
     all_signposts.extend(signposts)
     return signposts
 
-def old_parse_signpost_bytes(some_bytes, bank=None, map_group=None, map_id=None, debug=True):
-    assert len(some_bytes) % signpost_byte_size == 0, "wrong number of bytes"
-    signposts = []
-    for bytes in helpers.grouper(some_bytes, count=signpost_byte_size):
-        y = int(bytes[0], 16)
-        x = int(bytes[1], 16)
-        func = int(bytes[2], 16)
-
-        additional = {}
-        if func in [0, 1, 2, 3, 4]:
-            logging.debug(
-                "parsing signpost script.. signpost is at x={x} y={y}"
-                .format(x=x, y=y)
-            )
-            script_ptr_byte1 = int(bytes[3], 16)
-            script_ptr_byte2 = int(bytes[4], 16)
-            script_pointer = script_ptr_byte1 + (script_ptr_byte2 << 8)
-
-            script_address = None
-            script = None
-
-            script_address = pointers.calculate_pointer(script_pointer, bank)
-            script = parse_script_engine_script_at(script_address, map_group=map_group, map_id=map_id)
-
-            additional = {
-            "script_ptr": script_pointer,
-            "script_pointer": {"1": script_ptr_byte1, "2": script_ptr_byte2},
-            "script_address": script_address,
-            "script": script,
-            }
-        elif func in [5, 6]:
-            logging.debug(
-                "parsing signpost script.. signpost is at x={x} y={y}"
-                .format(x=x, y=y)
-            )
-
-            ptr_byte1 = int(bytes[3], 16)
-            ptr_byte2 = int(bytes[4], 16)
-            pointer = ptr_byte1 + (ptr_byte2 << 8)
-            address = pointers.calculate_pointer(pointer, bank)
-            bit_table_byte1 = ord(rom[address])
-            bit_table_byte2 = ord(rom[address+1])
-            script_ptr_byte1 = ord(rom[address+2])
-            script_ptr_byte2 = ord(rom[address+3])
-            script_address = calculate_pointer_from_bytes_at(address+2, bank=bank)
-            script = parse_script_engine_script_at(script_address, map_group=map_group, map_id=map_id)
-
-            additional = {
-            "bit_table_bytes": {"1": bit_table_byte1, "2": bit_table_byte2},
-            "script_ptr": script_ptr_byte1 + (script_ptr_byte2 << 8),
-            "script_pointer": {"1": script_ptr_byte1, "2": script_ptr_byte2},
-            "script_address": script_address,
-            "script": script,
-            }
-        else:
-            logging.debug(".. type 7 or 8 signpost not parsed yet.")
-
-        spost = {
-            "y": y,
-            "x": x,
-            "func": func,
-        }
-        spost.update(additional)
-        signposts.append(spost)
-    return signposts
-
-
 class MapHeader:
     base_label = "MapHeader_"
 
@@ -4565,40 +4479,6 @@ def parse_map_header_at(address, map_group=None, map_id=None, debug=True):
     all_map_headers.append(map_header)
     return map_header
 
-def old_parse_map_header_at(address, map_group=None, map_id=None, debug=True):
-    """parses an arbitrary map header at some address"""
-    logging.debug("parsing a map header at {0}".format(hex(address)))
-    bytes = rom_interval(address, map_header_byte_size, strings=False, debug=debug)
-    bank = bytes[0]
-    tileset = bytes[1]
-    permission = bytes[2]
-    second_map_header_address = pointers.calculate_pointer(bytes[3] + (bytes[4] << 8), 0x25)
-    location_on_world_map = bytes[5] # pokegear world map location
-    music = bytes[6]
-    time_of_day = bytes[7]
-    fishing_group = bytes[8]
-
-    map_header = {
-        "bank": bank,
-        "tileset": tileset,
-        "permission": permission, # map type?
-        "second_map_header_pointer": {"1": bytes[3], "2": bytes[4]},
-        "second_map_header_address": second_map_header_address,
-        "location_on_world_map": location_on_world_map, # area
-        "music": music,
-        "time_of_day": time_of_day,
-        "fishing": fishing_group,
-    }
-    logging.debug("second map header address is {0}".format(hex(second_map_header_address)))
-    map_header["second_map_header"] = old_parse_second_map_header_at(second_map_header_address, debug=debug)
-    event_header_address = map_header["second_map_header"]["event_address"]
-    script_header_address = map_header["second_map_header"]["script_address"]
-    # maybe event_header and script_header should be put under map_header["second_map_header"]
-    map_header["event_header"] = old_parse_map_event_header_at(event_header_address, map_group=map_group, map_id=map_id, debug=debug)
-    map_header["script_header"] = old_parse_map_script_header_at(script_header_address, map_group=map_group, map_id=map_id, debug=debug)
-    return map_header
-
-
 def get_direction(connection_byte, connection_id):
     """
     Given a connection byte and a connection id, which direction is this
@@ -5427,39 +5307,6 @@ def parse_second_map_header_at(address, map_group=None, map_id=None, debug=True)
     all_second_map_headers.append(smh)
     return smh
 
-def old_parse_second_map_header_at(address, map_group=None, map_id=None, debug=True):
-    """each map has a second map header"""
-    bytes = rom_interval(address, second_map_header_byte_size, strings=False)
-    border_block = bytes[0]
-    height = bytes[1]
-    width = bytes[2]
-    blockdata_bank = bytes[3]
-    blockdata_pointer = bytes[4] + (bytes[5] << 8)
-    blockdata_address = pointers.calculate_pointer(blockdata_pointer, blockdata_bank)
-    script_bank = bytes[6]
-    script_pointer = bytes[7] + (bytes[8] << 8)
-    script_address = pointers.calculate_pointer(script_pointer, script_bank)
-    event_bank = script_bank
-    event_pointer = bytes[9] + (bytes[10] << 8)
-    event_address = pointers.calculate_pointer(event_pointer, event_bank)
-    connections = bytes[11]
-    return {
-        "border_block": border_block,
-        "height": height,
-        "width": width,
-        "blockdata_bank": blockdata_bank,
-        "blockdata_pointer": {"1": bytes[4], "2": bytes[5]},
-        "blockdata_address": blockdata_address,
-        "script_bank": script_bank,
-        "script_pointer": {"1": bytes[7], "2": bytes[8]},
-        "script_address": script_address,
-        "event_bank": event_bank,
-        "event_pointer": {"1": bytes[9], "2": bytes[10]},
-        "event_address": event_address,
-        "connections": connections,
-    }
-
-
 class MapBlockData:
     base_label = "MapBlockData_"
     maps_path = os.path.realpath(os.path.join(os.path.realpath("."), "../maps"))
@@ -5645,48 +5492,6 @@ def parse_map_event_header_at(address, map_group=None, map_id=None, debug=True,
     all_map_event_headers.append(ev)
     return ev
 
-def old_parse_map_event_header_at(address, map_group=None, map_id=None, debug=True):
-    """parse crystal map event header byte structure thing"""
-    returnable = {}
-
-    bank = pointers.calculate_bank(address)
-
-    logging.debug("event header address is {0}".format(hex(address)))
-    filler1 = ord(rom[address])
-    filler2 = ord(rom[address+1])
-    returnable.update({"1": filler1, "2": filler2})
-
-    # warps
-    warp_count = ord(rom[address+2])
-    warp_byte_count = warp_byte_size * warp_count
-    warps = rom_interval(address+3, warp_byte_count)
-    after_warps = address + 3 + warp_byte_count
-    returnable.update({"warp_count": warp_count, "warps": old_parse_warp_bytes(warps)})
-
-    # triggers (based on xy location)
-    trigger_count = ord(rom[after_warps])
-    trigger_byte_count = trigger_byte_size * trigger_count
-    triggers = rom_interval(after_warps+1, trigger_byte_count)
-    after_triggers = after_warps + 1 + trigger_byte_count
-    returnable.update({"xy_trigger_count": trigger_count, "xy_triggers": old_parse_xy_trigger_bytes(triggers, bank=bank, map_group=map_group, map_id=map_id)})
-
-    # signposts
-    signpost_count = ord(rom[after_triggers])
-    signpost_byte_count = signpost_byte_size * signpost_count
-    signposts = rom_interval(after_triggers+1, signpost_byte_count)
-    after_signposts = after_triggers + 1 + signpost_byte_count
-    returnable.update({"signpost_count": signpost_count, "signposts": old_parse_signpost_bytes(signposts, bank=bank, map_group=map_group, map_id=map_id)})
-
-    # people events
-    people_event_count = ord(rom[after_signposts])
-    people_event_byte_count = people_event_byte_size * people_event_count
-    people_events_bytes = rom_interval(after_signposts+1, people_event_byte_count)
-    people_events = old_parse_people_event_bytes(people_events_bytes, address=after_signposts+1, map_group=map_group, map_id=map_id)
-    returnable.update({"people_event_count": people_event_count, "people_events": people_events})
-
-    return returnable
-
-
 class MapScriptHeader:
     """parses a script header
 
@@ -5851,223 +5656,6 @@ def parse_map_script_header_at(address, map_group=None, map_id=None, debug=True)
     all_map_script_headers.append(evv)
     return evv
 
-def old_parse_map_script_header_at(address, map_group=None, map_id=None, debug=True):
-    logging.debug("starting to parse the map's script header..")
-    #[[Number1 of pointers] Number1 * [2byte pointer to script][00][00]]
-    ptr_line_size = 4 #[2byte pointer to script][00][00]
-    trigger_ptr_cnt = ord(rom[address])
-    trigger_pointers = helpers.grouper(rom_interval(address+1, trigger_ptr_cnt * ptr_line_size, strings=False), count=ptr_line_size)
-    triggers = {}
-    for index, trigger_pointer in enumerate(trigger_pointers):
-        logging.debug("parsing a trigger header...")
-        byte1 = trigger_pointer[0]
-        byte2 = trigger_pointer[1]
-        ptr   = byte1 + (byte2 << 8)
-        trigger_address = pointers.calculate_pointer(ptr, pointers.calculate_bank(address))
-        trigger_script  = parse_script_engine_script_at(trigger_address, map_group=map_group, map_id=map_id)
-        triggers[index] = {
-            "script": trigger_script,
-            "address": trigger_address,
-            "pointer": {"1": byte1, "2": byte2},
-        }
-
-    # bump ahead in the byte stream
-    address += trigger_ptr_cnt * ptr_line_size + 1
-
-    #[[Number2 of pointers] Number2 * [hook number][2byte pointer to script]]
-    callback_ptr_line_size = 3
-    callback_ptr_cnt = ord(rom[address])
-    callback_ptrs = helpers.grouper(rom_interval(address+1, callback_ptr_cnt * callback_ptr_line_size, strings=False), count=callback_ptr_line_size)
-    callback_pointers = {}
-    callbacks = {}
-    for index, callback_line in enumerate(callback_ptrs):
-        logging.debug("parsing a callback header..")
-        hook_byte = callback_line[0] # 1, 2, 3, 4, 5
-        callback_byte1 = callback_line[1]
-        callback_byte2 = callback_line[2]
-        callback_ptr = callback_byte1 + (callback_byte2 << 8)
-        callback_address = pointers.calculate_pointer(callback_ptr, pointers.calculate_bank(address))
-        callback_script = parse_script_engine_script_at(callback_address)
-        callback_pointers[len(callback_pointers.keys())] = [hook_byte, callback_ptr]
-        callbacks[index] = {
-            "script": callback_script,
-            "address": callback_address,
-            "pointer": {"1": callback_byte1, "2": callback_byte2},
-        }
-
-    # XXX do these triggers/callbacks call asm or script engine scripts?
-    return {
-        #"trigger_ptr_cnt": trigger_ptr_cnt,
-        "trigger_pointers": trigger_pointers,
-        #"callback_ptr_cnt": callback_ptr_cnt,
-        #"callback_ptr_scripts": callback_ptrs,
-        "callback_pointers": callback_pointers,
-        "trigger_scripts": triggers,
-        "callback_scripts": callbacks,
-    }
-
-def old_parse_trainer_header_at(address, map_group=None, map_id=None, debug=True):
-    bank = pointers.calculate_bank(address)
-    bytes = rom_interval(address, 12, strings=False)
-    bit_number = bytes[0] + (bytes[1] << 8)
-    trainer_group = bytes[2]
-    trainer_id = bytes[3]
-    text_when_seen_ptr = calculate_pointer_from_bytes_at(address+4, bank=bank)
-    text_when_seen = parse_text_engine_script_at(text_when_seen_ptr, map_group=map_group, map_id=map_id, debug=debug)
-    text_when_trainer_beaten_ptr = calculate_pointer_from_bytes_at(address+6, bank=bank)
-    text_when_trainer_beaten = parse_text_engine_script_at(text_when_trainer_beaten_ptr, map_group=map_group, map_id=map_id, debug=debug)
-
-    if [ord(rom[address+8]), ord(rom[address+9])] == [0, 0]:
-        script_when_lost_ptr = 0
-        script_when_lost = None
-    else:
-        logging.debug("parsing script-when-lost")
-        script_when_lost_ptr = calculate_pointer_from_bytes_at(address+8, bank=bank)
-        script_when_lost = None
-        silver_avoids = [0xfa53]
-        if script_when_lost_ptr > 0x4000 and not script_when_lost_ptr in silver_avoids:
-            script_when_lost = parse_script_engine_script_at(script_when_lost_ptr, map_group=map_group, map_id=map_id, debug=debug)
-
-    logging.debug("parsing script-talk-again") # or is this a text?
-    script_talk_again_ptr = calculate_pointer_from_bytes_at(address+10, bank=bank)
-    script_talk_again = None
-    if script_talk_again_ptr > 0x4000:
-        script_talk_again = parse_script_engine_script_at(script_talk_again_ptr, map_group=map_group, map_id=map_id, debug=debug)
-
-    return {
-        "bit_number": bit_number,
-        "trainer_group": trainer_group,
-        "trainer_id": trainer_id,
-        "text_when_seen_ptr": text_when_seen_ptr,
-        "text_when_seen": text_when_seen,
-        "text_when_trainer_beaten_ptr": text_when_trainer_beaten_ptr,
-        "text_when_trainer_beaten": text_when_trainer_beaten,
-        "script_when_lost_ptr": script_when_lost_ptr,
-        "script_when_lost": script_when_lost,
-        "script_talk_again_ptr": script_talk_again_ptr,
-        "script_talk_again": script_talk_again,
-    }
-
-def old_parse_people_event_bytes(some_bytes, address=None, map_group=None, map_id=None, debug=True):
-    """parse some number of people-events from the data
-    see PeopleEvent
-    see http://hax.iimarck.us/files/scriptingcodes_eng.htm#Scripthdr
-
-    For example, map 1.1 (group 1 map 1) has four person-events.
-
-        37 05 07 06 00 FF FF 00 00 02 40 FF FF
-        3B 08 0C 05 01 FF FF 00 00 05 40 FF FF
-        3A 07 06 06 00 FF FF A0 00 08 40 FF FF
-        29 05 0B 06 00 FF FF 00 00 0B 40 FF FF
-
-    max of 14 people per map?
-    """
-    assert len(some_bytes) % people_event_byte_size == 0, "wrong number of bytes"
-
-    # address is not actually required for this function to work...
-    bank = None
-    if address:
-        bank = pointers.calculate_bank(address)
-
-    people_events = []
-    for bytes in helpers.grouper(some_bytes, count=people_event_byte_size):
-        pict = int(bytes[0], 16)
-        y = int(bytes[1], 16)    # y from top + 4
-        x = int(bytes[2], 16)    # x from left + 4
-        face = int(bytes[3], 16) # 0-4 for regular, 6-9 for static facing
-        move = int(bytes[4], 16)
-        clock_time_byte1 = int(bytes[5], 16)
-        clock_time_byte2 = int(bytes[6], 16)
-        color_function_byte = int(bytes[7], 16) # Color|Function
-        trainer_sight_range = int(bytes[8], 16)
-
-        lower_bits = color_function_byte & 0xF
-        #lower_bits_high = lower_bits >> 2
-        #lower_bits_low = lower_bits & 3
-        higher_bits = color_function_byte >> 4
-        #higher_bits_high = higher_bits >> 2
-        #higher_bits_low = higher_bits & 3
-
-        is_regular_script = lower_bits == 00
-        # pointer points to script
-        is_give_item = lower_bits == 01
-        # pointer points to [Item no.][Amount]
-        is_trainer = lower_bits == 02
-        # pointer points to trainer header
-
-        # goldmap called these next two bytes "text_block" and "text_bank"?
-        script_pointer_byte1 = int(bytes[9], 16)
-        script_pointer_byte2 = int(bytes[10], 16)
-        script_pointer = script_pointer_byte1 + (script_pointer_byte2 << 8)
-        # calculate the full address by assuming it's in the current bank
-        # but what if it's not in the same bank?
-        extra_portion = {}
-        if bank:
-            ptr_address = pointers.calculate_pointer(script_pointer, bank)
-            if is_regular_script:
-                logging.debug(
-                    "parsing a person-script at x={x} y={y} address={address}"
-                    .format(x=(x-4), y=(y-4), address=hex(ptr_address))
-                )
-                script = parse_script_engine_script_at(ptr_address, map_group=map_group, map_id=map_id)
-                extra_portion = {
-                    "script_address": ptr_address,
-                    "script": script,
-                    "event_type": "script",
-                }
-            if is_give_item:
-                logging.debug("not parsing give item event.. [item id][quantity]")
-                extra_portion = {
-                    "event_type": "give_item",
-                    "give_item_data_address": ptr_address,
-                    "item_id": ord(rom[ptr_address]),
-                    "item_qty": ord(rom[ptr_address+1]),
-                }
-            if is_trainer:
-                logging.debug("parsing a trainer (person-event) at x={x} y={y}".format(x=x, y=y))
-                parsed_trainer = old_parse_trainer_header_at(ptr_address, map_group=map_group, map_id=map_id)
-                extra_portion = {
-                    "event_type": "trainer",
-                    "trainer_data_address": ptr_address,
-                    "trainer_data": parsed_trainer,
-                }
-
-        # XXX not sure what's going on here
-        # bit no. of bit table 1 (hidden if set)
-        # note: FFFF for none
-        when_byte = int(bytes[11], 16)
-        hide = int(bytes[12], 16)
-
-        bit_number_of_bit_table1_byte2 = int(bytes[11], 16)
-        bit_number_of_bit_table1_byte1 = int(bytes[12], 16)
-        bit_number_of_bit_table1 = bit_number_of_bit_table1_byte1 + (bit_number_of_bit_table1_byte2 << 8)
-
-        people_event = {
-            "pict": pict,
-            "y": y,                      # y from top + 4
-            "x": x,                      # x from left + 4
-            "face": face,                # 0-4 for regular, 6-9 for static facing
-            "move": move,
-            "clock_time": {"1": clock_time_byte1,
-                           "2": clock_time_byte2},       # clock/time setting byte 1
-            "color_function_byte": color_function_byte,  # Color|Function
-            "trainer_sight_range": trainer_sight_range,  # trainer range of sight
-            "script_pointer": {"1": script_pointer_byte1,
-                               "2": script_pointer_byte2},
-
-            #"text_block": text_block,   # script pointer byte 1
-            #"text_bank": text_bank,     # script pointer byte 2
-            "when_byte": when_byte,      # bit no. of bit table 1 (hidden if set)
-            "hide": hide,                # note: FFFF for none
-
-            "is_trainer": is_trainer,
-            "is_regular_script": is_regular_script,
-            "is_give_item": is_give_item,
-        }
-        people_event.update(extra_portion)
-        people_events.append(people_event)
-    return people_events
-
 def parse_map_header_by_id(*args, **kwargs):
     """convenience function to parse a specific map"""
     map_group, map_id = None, None
diff --git a/pokemontools/crystalparts/old_parsers.py b/pokemontools/crystalparts/old_parsers.py
new file mode 100644
index 0000000..b23ab5d
--- /dev/null
+++ b/pokemontools/crystalparts/old_parsers.py
@@ -0,0 +1,425 @@
+"""
+Some old methods rescued from crystal.py
+"""
+
+import pointers
+
+map_header_byte_size = ...
+rom_interval = ...
+
+all_map_headers = []
+
+def old_parse_map_script_header_at(address, map_group=None, map_id=None, debug=True):
+    logging.debug("starting to parse the map's script header..")
+    #[[Number1 of pointers] Number1 * [2byte pointer to script][00][00]]
+    ptr_line_size = 4 #[2byte pointer to script][00][00]
+    trigger_ptr_cnt = ord(rom[address])
+    trigger_pointers = helpers.grouper(rom_interval(address+1, trigger_ptr_cnt * ptr_line_size, strings=False), count=ptr_line_size)
+    triggers = {}
+    for index, trigger_pointer in enumerate(trigger_pointers):
+        logging.debug("parsing a trigger header...")
+        byte1 = trigger_pointer[0]
+        byte2 = trigger_pointer[1]
+        ptr   = byte1 + (byte2 << 8)
+        trigger_address = pointers.calculate_pointer(ptr, pointers.calculate_bank(address))
+        trigger_script  = parse_script_engine_script_at(trigger_address, map_group=map_group, map_id=map_id)
+        triggers[index] = {
+            "script": trigger_script,
+            "address": trigger_address,
+            "pointer": {"1": byte1, "2": byte2},
+        }
+
+    # bump ahead in the byte stream
+    address += trigger_ptr_cnt * ptr_line_size + 1
+
+    #[[Number2 of pointers] Number2 * [hook number][2byte pointer to script]]
+    callback_ptr_line_size = 3
+    callback_ptr_cnt = ord(rom[address])
+    callback_ptrs = helpers.grouper(rom_interval(address+1, callback_ptr_cnt * callback_ptr_line_size, strings=False), count=callback_ptr_line_size)
+    callback_pointers = {}
+    callbacks = {}
+    for index, callback_line in enumerate(callback_ptrs):
+        logging.debug("parsing a callback header..")
+        hook_byte = callback_line[0] # 1, 2, 3, 4, 5
+        callback_byte1 = callback_line[1]
+        callback_byte2 = callback_line[2]
+        callback_ptr = callback_byte1 + (callback_byte2 << 8)
+        callback_address = pointers.calculate_pointer(callback_ptr, pointers.calculate_bank(address))
+        callback_script = parse_script_engine_script_at(callback_address)
+        callback_pointers[len(callback_pointers.keys())] = [hook_byte, callback_ptr]
+        callbacks[index] = {
+            "script": callback_script,
+            "address": callback_address,
+            "pointer": {"1": callback_byte1, "2": callback_byte2},
+        }
+
+    # XXX do these triggers/callbacks call asm or script engine scripts?
+    return {
+        #"trigger_ptr_cnt": trigger_ptr_cnt,
+        "trigger_pointers": trigger_pointers,
+        #"callback_ptr_cnt": callback_ptr_cnt,
+        #"callback_ptr_scripts": callback_ptrs,
+        "callback_pointers": callback_pointers,
+        "trigger_scripts": triggers,
+        "callback_scripts": callbacks,
+    }
+
+
+def old_parse_map_header_at(address, map_group=None, map_id=None, debug=True):
+    """parses an arbitrary map header at some address"""
+    logging.debug("parsing a map header at {0}".format(hex(address)))
+    bytes = rom_interval(address, map_header_byte_size, strings=False, debug=debug)
+    bank = bytes[0]
+    tileset = bytes[1]
+    permission = bytes[2]
+    second_map_header_address = pointers.calculate_pointer(bytes[3] + (bytes[4] << 8), 0x25)
+    location_on_world_map = bytes[5] # pokegear world map location
+    music = bytes[6]
+    time_of_day = bytes[7]
+    fishing_group = bytes[8]
+
+    map_header = {
+        "bank": bank,
+        "tileset": tileset,
+        "permission": permission, # map type?
+        "second_map_header_pointer": {"1": bytes[3], "2": bytes[4]},
+        "second_map_header_address": second_map_header_address,
+        "location_on_world_map": location_on_world_map, # area
+        "music": music,
+        "time_of_day": time_of_day,
+        "fishing": fishing_group,
+    }
+    logging.debug("second map header address is {0}".format(hex(second_map_header_address)))
+    map_header["second_map_header"] = old_parse_second_map_header_at(second_map_header_address, debug=debug)
+    event_header_address = map_header["second_map_header"]["event_address"]
+    script_header_address = map_header["second_map_header"]["script_address"]
+    # maybe event_header and script_header should be put under map_header["second_map_header"]
+    map_header["event_header"] = old_parse_map_event_header_at(event_header_address, map_group=map_group, map_id=map_id, debug=debug)
+    map_header["script_header"] = old_parse_map_script_header_at(script_header_address, map_group=map_group, map_id=map_id, debug=debug)
+    return map_header
+
+all_second_map_headers = []
+
+def old_parse_second_map_header_at(address, map_group=None, map_id=None, debug=True):
+    """each map has a second map header"""
+    bytes = rom_interval(address, second_map_header_byte_size, strings=False)
+    border_block = bytes[0]
+    height = bytes[1]
+    width = bytes[2]
+    blockdata_bank = bytes[3]
+    blockdata_pointer = bytes[4] + (bytes[5] << 8)
+    blockdata_address = pointers.calculate_pointer(blockdata_pointer, blockdata_bank)
+    script_bank = bytes[6]
+    script_pointer = bytes[7] + (bytes[8] << 8)
+    script_address = pointers.calculate_pointer(script_pointer, script_bank)
+    event_bank = script_bank
+    event_pointer = bytes[9] + (bytes[10] << 8)
+    event_address = pointers.calculate_pointer(event_pointer, event_bank)
+    connections = bytes[11]
+    return {
+        "border_block": border_block,
+        "height": height,
+        "width": width,
+        "blockdata_bank": blockdata_bank,
+        "blockdata_pointer": {"1": bytes[4], "2": bytes[5]},
+        "blockdata_address": blockdata_address,
+        "script_bank": script_bank,
+        "script_pointer": {"1": bytes[7], "2": bytes[8]},
+        "script_address": script_address,
+        "event_bank": event_bank,
+        "event_pointer": {"1": bytes[9], "2": bytes[10]},
+        "event_address": event_address,
+        "connections": connections,
+    }
+
+def old_parse_warp_bytes(some_bytes, debug=True):
+    """parse some number of warps from the data"""
+    assert len(some_bytes) % warp_byte_size == 0, "wrong number of bytes"
+    warps = []
+    for bytes in helpers.grouper(some_bytes, count=warp_byte_size):
+        y = int(bytes[0], 16)
+        x = int(bytes[1], 16)
+        warp_to = int(bytes[2], 16)
+        map_group = int(bytes[3], 16)
+        map_id = int(bytes[4], 16)
+        warps.append({
+            "y": y,
+            "x": x,
+            "warp_to": warp_to,
+            "map_group": map_group,
+            "map_id": map_id,
+        })
+    return warps
+
+def old_parse_signpost_bytes(some_bytes, bank=None, map_group=None, map_id=None, debug=True):
+    assert len(some_bytes) % signpost_byte_size == 0, "wrong number of bytes"
+    signposts = []
+    for bytes in helpers.grouper(some_bytes, count=signpost_byte_size):
+        y = int(bytes[0], 16)
+        x = int(bytes[1], 16)
+        func = int(bytes[2], 16)
+
+        additional = {}
+        if func in [0, 1, 2, 3, 4]:
+            logging.debug(
+                "parsing signpost script.. signpost is at x={x} y={y}"
+                .format(x=x, y=y)
+            )
+            script_ptr_byte1 = int(bytes[3], 16)
+            script_ptr_byte2 = int(bytes[4], 16)
+            script_pointer = script_ptr_byte1 + (script_ptr_byte2 << 8)
+
+            script_address = None
+            script = None
+
+            script_address = pointers.calculate_pointer(script_pointer, bank)
+            script = parse_script_engine_script_at(script_address, map_group=map_group, map_id=map_id)
+
+            additional = {
+            "script_ptr": script_pointer,
+            "script_pointer": {"1": script_ptr_byte1, "2": script_ptr_byte2},
+            "script_address": script_address,
+            "script": script,
+            }
+        elif func in [5, 6]:
+            logging.debug(
+                "parsing signpost script.. signpost is at x={x} y={y}"
+                .format(x=x, y=y)
+            )
+
+            ptr_byte1 = int(bytes[3], 16)
+            ptr_byte2 = int(bytes[4], 16)
+            pointer = ptr_byte1 + (ptr_byte2 << 8)
+            address = pointers.calculate_pointer(pointer, bank)
+            bit_table_byte1 = ord(rom[address])
+            bit_table_byte2 = ord(rom[address+1])
+            script_ptr_byte1 = ord(rom[address+2])
+            script_ptr_byte2 = ord(rom[address+3])
+            script_address = calculate_pointer_from_bytes_at(address+2, bank=bank)
+            script = parse_script_engine_script_at(script_address, map_group=map_group, map_id=map_id)
+
+            additional = {
+            "bit_table_bytes": {"1": bit_table_byte1, "2": bit_table_byte2},
+            "script_ptr": script_ptr_byte1 + (script_ptr_byte2 << 8),
+            "script_pointer": {"1": script_ptr_byte1, "2": script_ptr_byte2},
+            "script_address": script_address,
+            "script": script,
+            }
+        else:
+            logging.debug(".. type 7 or 8 signpost not parsed yet.")
+
+        spost = {
+            "y": y,
+            "x": x,
+            "func": func,
+        }
+        spost.update(additional)
+        signposts.append(spost)
+    return signposts
+
+def old_parse_people_event_bytes(some_bytes, address=None, map_group=None, map_id=None, debug=True):
+    """parse some number of people-events from the data
+    see http://hax.iimarck.us/files/scriptingcodes_eng.htm#Scripthdr
+
+    For example, map 1.1 (group 1 map 1) has four person-events.
+
+        37 05 07 06 00 FF FF 00 00 02 40 FF FF
+        3B 08 0C 05 01 FF FF 00 00 05 40 FF FF
+        3A 07 06 06 00 FF FF A0 00 08 40 FF FF
+        29 05 0B 06 00 FF FF 00 00 0B 40 FF FF
+    """
+    assert len(some_bytes) % people_event_byte_size == 0, "wrong number of bytes"
+
+    # address is not actually required for this function to work...
+    bank = None 
+    if address:
+        bank = pointers.calculate_bank(address)
+
+    people_events = [] 
+    for bytes in helpers.grouper(some_bytes, count=people_event_byte_size):
+        pict = int(bytes[0], 16)
+        y = int(bytes[1], 16)    # y from top + 4
+        x = int(bytes[2], 16)    # x from left + 4
+        face = int(bytes[3], 16) # 0-4 for regular, 6-9 for static facing
+        move = int(bytes[4], 16)
+        clock_time_byte1 = int(bytes[5], 16)
+        clock_time_byte2 = int(bytes[6], 16)
+        color_function_byte = int(bytes[7], 16) # Color|Function
+        trainer_sight_range = int(bytes[8], 16)
+
+        lower_bits = color_function_byte & 0xF
+        #lower_bits_high = lower_bits >> 2
+        #lower_bits_low = lower_bits & 3
+        higher_bits = color_function_byte >> 4
+        #higher_bits_high = higher_bits >> 2
+        #higher_bits_low = higher_bits & 3
+
+        is_regular_script = lower_bits == 00
+        # pointer points to script
+        is_give_item = lower_bits == 01
+        # pointer points to [Item no.][Amount]
+        is_trainer = lower_bits == 02
+        # pointer points to trainer header
+
+        # goldmap called these next two bytes "text_block" and "text_bank"?
+        script_pointer_byte1 = int(bytes[9], 16)
+        script_pointer_byte2 = int(bytes[10], 16)
+        script_pointer = script_pointer_byte1 + (script_pointer_byte2 << 8)
+        # calculate the full address by assuming it's in the current bank
+        # but what if it's not in the same bank?
+        extra_portion = {}
+        if bank:
+            ptr_address = pointers.calculate_pointer(script_pointer, bank)
+            if is_regular_script:
+                logging.debug(
+                    "parsing a person-script at x={x} y={y} address={address}"
+                    .format(
+                        x=(x-4),
+                        y=(y-4),
+                        address=hex(ptr_address),
+                    )
+                )
+                script = parse_script_engine_script_at(ptr_address, map_group=map_group, map_id=map_id)
+                extra_portion = {
+                    "script_address": ptr_address,
+                    "script": script,
+                    "event_type": "script",
+                }
+            if is_give_item:
+                logging.debug("not parsing give item event.. [item id][quantity]")
+                extra_portion = {
+                    "event_type": "give_item",
+                    "give_item_data_address": ptr_address,
+                    "item_id": ord(rom[ptr_address]),
+                    "item_qty": ord(rom[ptr_address+1]),
+                }
+            if is_trainer:
+                logging.debug(
+                    "parsing a trainer (person-event) at x={x} y={y}"
+                    .format(x=x, y=y)
+                )
+                parsed_trainer = parse_trainer_header_at(ptr_address, map_group=map_group, map_id=map_id)
+                extra_portion = {
+                    "event_type": "trainer",
+                    "trainer_data_address": ptr_address,
+                    "trainer_data": parsed_trainer,
+                }
+
+        # XXX not sure what's going on here
+        # bit no. of bit table 1 (hidden if set)
+        # note: FFFF for none
+        when_byte = int(bytes[11], 16)
+        hide = int(bytes[12], 16)
+
+        bit_number_of_bit_table1_byte2 = int(bytes[11], 16)
+        bit_number_of_bit_table1_byte1 = int(bytes[12], 16)
+        bit_number_of_bit_table1 = bit_number_of_bit_table1_byte1 + (bit_number_of_bit_table1_byte2 << 8)
+
+        people_event = {
+            "pict": pict,
+            "y": y,                      # y from top + 4
+            "x": x,                      # x from left + 4
+            "face": face,                # 0-4 for regular, 6-9 for static facing
+            "move": move,
+            "clock_time": {"1": clock_time_byte1,
+                           "2": clock_time_byte2},       # clock/time setting byte 1
+            "color_function_byte": color_function_byte,  # Color|Function
+            "trainer_sight_range": trainer_sight_range,  # trainer range of sight
+            "script_pointer": {"1": script_pointer_byte1,
+                               "2": script_pointer_byte2},
+
+            #"text_block": text_block,   # script pointer byte 1
+            #"text_bank": text_bank,     # script pointer byte 2
+            "when_byte": when_byte,      # bit no. of bit table 1 (hidden if set)
+            "hide": hide,                # note: FFFF for none
+
+            "is_trainer": is_trainer,
+            "is_regular_script": is_regular_script,
+            "is_give_item": is_give_item,
+        }
+        people_event.update(extra_portion)
+        people_events.append(people_event)
+    return people_events
+
+def old_parse_trainer_header_at(address, map_group=None, map_id=None, debug=True):
+    bank = pointers.calculate_bank(address)
+    bytes = rom_interval(address, 12, strings=False)
+    bit_number = bytes[0] + (bytes[1] << 8)
+    trainer_group = bytes[2]
+    trainer_id = bytes[3]
+    text_when_seen_ptr = calculate_pointer_from_bytes_at(address+4, bank=bank)
+    text_when_seen = parse_text_engine_script_at(text_when_seen_ptr, map_group=map_group, map_id=map_id, debug=debug)
+    text_when_trainer_beaten_ptr = calculate_pointer_from_bytes_at(address+6, bank=bank)
+    text_when_trainer_beaten = parse_text_engine_script_at(text_when_trainer_beaten_ptr, map_group=map_group, map_id=map_id, debug=debug)
+
+    if [ord(rom[address+8]), ord(rom[address+9])] == [0, 0]:
+        script_when_lost_ptr = 0
+        script_when_lost = None
+    else:
+        logging.debug("parsing script-when-lost")
+        script_when_lost_ptr = calculate_pointer_from_bytes_at(address+8, bank=bank)
+        script_when_lost = None
+        silver_avoids = [0xfa53]
+        if script_when_lost_ptr > 0x4000 and not script_when_lost_ptr in silver_avoids:
+            script_when_lost = parse_script_engine_script_at(script_when_lost_ptr, map_group=map_group, map_id=map_id, debug=debug)
+
+    logging.debug("parsing script-talk-again") # or is this a text?
+    script_talk_again_ptr = calculate_pointer_from_bytes_at(address+10, bank=bank)
+    script_talk_again = None
+    if script_talk_again_ptr > 0x4000:
+        script_talk_again = parse_script_engine_script_at(script_talk_again_ptr, map_group=map_group, map_id=map_id, debug=debug)
+
+    return {
+        "bit_number": bit_number,
+        "trainer_group": trainer_group,
+        "trainer_id": trainer_id,
+        "text_when_seen_ptr": text_when_seen_ptr,
+        "text_when_seen": text_when_seen,
+        "text_when_trainer_beaten_ptr": text_when_trainer_beaten_ptr,
+        "text_when_trainer_beaten": text_when_trainer_beaten,
+        "script_when_lost_ptr": script_when_lost_ptr,
+        "script_when_lost": script_when_lost,
+        "script_talk_again_ptr": script_talk_again_ptr,
+        "script_talk_again": script_talk_again,
+    }
+
+def old_parse_map_event_header_at(address, map_group=None, map_id=None, debug=True):
+    """parse crystal map event header byte structure thing"""
+    returnable = {}
+
+    bank = pointers.calculate_bank(address)
+
+    logging.debug("event header address is {0}".format(hex(address)))
+    filler1 = ord(rom[address])
+    filler2 = ord(rom[address+1])
+    returnable.update({"1": filler1, "2": filler2})
+
+    # warps
+    warp_count = ord(rom[address+2])
+    warp_byte_count = warp_byte_size * warp_count
+    warps = rom_interval(address+3, warp_byte_count)
+    after_warps = address + 3 + warp_byte_count
+    returnable.update({"warp_count": warp_count, "warps": old_parse_warp_bytes(warps)})
+
+    # triggers (based on xy location)
+    trigger_count = ord(rom[after_warps])
+    trigger_byte_count = trigger_byte_size * trigger_count
+    triggers = rom_interval(after_warps+1, trigger_byte_count)
+    after_triggers = after_warps + 1 + trigger_byte_count
+    returnable.update({"xy_trigger_count": trigger_count, "xy_triggers": old_parse_xy_trigger_bytes(triggers, bank=bank, map_group=map_group, map_id=map_id)})
+
+    # signposts
+    signpost_count = ord(rom[after_triggers])
+    signpost_byte_count = signpost_byte_size * signpost_count
+    signposts = rom_interval(after_triggers+1, signpost_byte_count)
+    after_signposts = after_triggers + 1 + signpost_byte_count
+    returnable.update({"signpost_count": signpost_count, "signposts": old_parse_signpost_bytes(signposts, bank=bank, map_group=map_group, map_id=map_id)})
+
+    # people events
+    people_event_count = ord(rom[after_signposts])
+    people_event_byte_count = people_event_byte_size * people_event_count
+    people_events_bytes = rom_interval(after_signposts+1, people_event_byte_count)
+    people_events = old_parse_people_event_bytes(people_events_bytes, address=after_signposts+1, map_group=map_group, map_id=map_id)
+    returnable.update({"people_event_count": people_event_count, "people_events": people_events})
+
+    return returnable