Ejemplo n.º 1
0
 def read(data: ScnDataReader):
     field1 = data.string16(debug='player_name_repeated')
     field2 = data.float32(debug='unknown field 1')
     field3 = data.float32(debug='unknown field 2')
     field4 = data.uint16(debug='unknown field 3')
     field5 = data.uint16(debug='unknown field 4')
     field6 = data.uint8(debug='unknown field 5')
     field7 = data.uint16(debug='unknown field 6')
     field8 = []
     for j in range(0, 9):
         something = data.uint8(debug='unknown field {}'.format(j))
         field8.append(something)
     field9 = []
     for j in range(0, 9):
         something = data.uint32(debug='unknown field {}'.format(j))
         field9.append(something)
     field10 = data.float32(debug="unknown field")  # 1.00
     field11 = data.float32(
         debug="unknown field"
     )  # only seen 0. guess this could be float as well ?
     field12 = []
     for j in range(
             0, 9
     ):  # all 0's. guessing it could hold another list of 9 values?
         something = data.uint8(debug='unknown field {}'.format(j))
         field12.append(something)
     return UnknownPlayerDataStructure(field1, field2, field3, field4,
                                       field5, field6, field7, field8,
                                       field9, field10, field11, field12)
Ejemplo n.º 2
0
    def read_de(data: ScnDataReader):
        base = ScnEngineProperties.read_de(data)

        # expecting global victory conditions around here somewhere
        for i in range(0, 8):
            data.uint32(debug='unknown value a {}'.format(i))
        data.uint32(debug='unknown value b')  # 900
        data.uint32(debug='unknown value c')  # 9000

        # expecting diplomacy
        for i in range(0, 16):
            for j in range(0, 16):
                val = data.uint32()
                logging.debug("Unknown value from=%d to=%d val=%d", i, j,
                              val)  # lots of '3'.

        # expecting 12 individual victory conditions for each player
        for i in range(0, 16):
            for j in range(0, 12):
                # TODO read these ???
                data.read(60)

        check3 = data.int32(debug='check value 3')
        if check3 != -99:
            raise Exception(
                "Check value did not match in scenario data, giving up")

        # Probably allied victory
        for i in range(0, 16):
            data.uint32(debug='allied victory player {}'.format(i))

        # disabled tech
        for i in range(0, 16):
            for j in range(0, 20):
                disabled_tech_id = data.uint32()
                logging.debug("Disabled tech player %d, position %d: %d", i, j,
                              disabled_tech_id)

        data.uint32(debug='unknown field 1')
        data.uint32(debug='unknown field 2')
        data.uint32(debug='unknown field 3')  # might be full tech tree

        for j in range(0, 16):  # maybe ?
            data.uint32(debug='starting age player {}'.format(j))

        check4 = data.int32(debug='check value 2')
        if check4 != -99:
            raise Exception(
                "Check value did not match in scenario data, giving up")

        # view ?
        data.float32()
        data.float32()

        game_properties = ScnGameProperties(base)
        logging.debug(game_properties)
        return game_properties
Ejemplo n.º 3
0
def read_missile_unit(data: ScnDataReader):
    base_props = read_base_unit_props(data)
    animated_props = read_animated_unit_props(data)
    moving_unit_props = read_moving_unit_props(data)
    action_unit_props = read_action_unit_props(data)
    base_combat_unit_props = read_base_combat_unit_props(data)
    data.int8(debug='unknown')
    data.int32(debug='unknown')
    data.float32(debug='unknown')
Ejemplo n.º 4
0
 def read_classic(data: ScnDataReader, player_version: float):
     return WorldPlayer(
         data.float32() if player_version > 1.06 else 200.0,
         data.float32() if player_version > 1.06 else 200.0,
         data.float32() if player_version > 1.06 else 50.0,
         data.float32() if player_version > 1.06 else 100.0,
         data.float32() if player_version > 1.12 else 100.0,
         data.float32() if player_version > 1.12 else 0.0,
         data.float32() if player_version > 1.14 else 75.0,
     )
Ejemplo n.º 5
0
 def read_classic(data: ScnDataReader, file_version: float):
     return ScenarioObject(
         (data.float32(), data.float32(), data.float32()),
         data.uint32(),
         data.uint16(),
         data.uint8(),
         data.float32(),
         # Not used in AOE1
         -1 if file_version < 1.15 else data.uint16(),
         -1 if file_version < 1.13 else data.uint32())
Ejemplo n.º 6
0
def load(data: ScnDataReader) -> List[Civilization]:
    """
    Read all civilizations from here
    """
    data.mark("civilizations")
    num_civs = data.int16(debug='num_civs')
    for i in range(0, num_civs):
        data.uint8(debug='civ_type {}'.format(i))
        data.string_fixed(size=20, debug='civ_name {}'.format(i))
        civ_num_attributes = data.uint16(
            debug='civ_num_attributes {}'.format(i))
        civ_effect = data.int16(debug='civ_effect {}'.format(i))
        # civ_bonus_effect = data.int16(debug='civ_bonus_effect {}'.format(i)) # Might not exist in AOE1 dat.
        civ_attributes = [
            data.float32(debug='civ_attribute {} {}'.format(i, x))
            for x in range(0, civ_num_attributes)
        ]
        civ_icon_set = data.uint8(debug='civ_icon_set {}'.format(i))
        civ_num_units = data.uint16(debug='civ_num_units {}'.format(i))
        civ_unit_available = [
            data.boolean32(debug='civ_unit_available {} {}'.format(i, x))
            for x in range(0, civ_num_units)
        ]
        for j in range(0, civ_num_units):
            if not civ_unit_available[j]:
                continue
            read_unit(data)
    return []
Ejemplo n.º 7
0
 def read(data: ScnDataReader):
     effect_comamnd_type = data.uint8()
     effect_params = (
         data.int16(),
         data.int16(),
         data.int16(),
         data.float32()
     )
     return EffectCommand(effect_comamnd_type, effect_params)
Ejemplo n.º 8
0
    def read(data: ScnDataReader):
        data.boolean8(debug="border_enabled")
        data.boolean8(debug="border_random")
        data.string_fixed(size=13, debug='border_name')
        data.string_fixed(size=13, debug='border_texture_name')  # Maybe read as int and test agains -1?
        data.int32(debug='border_slp_id')
        data.int32(debug='border_slp_pointer')
        data.int32(debug='border_sound_id')
        data.uint8(debug='border_minimap_color_high')
        data.uint8(debug='border_minimap_color_medium')
        data.uint8(debug='border_minimap_color_low')
        # Same as terrain animation
        data.boolean8(debug='border_manimation_enabled')
        data.int16(debug='border_anim_num_frames')
        data.int16(debug='border_anim_num_pause_frames')
        data.float32(debug='border_anim_frame_interval')
        data.float32(debug='border_anim_replay_delay')
        data.int16(debug='border_anim_frame')
        data.int16(debug='border_anim_draw_frame')
        data.float32(debug='border_anim_animate_last')
        data.boolean8(debug='border_anim_frame_changed')
        data.boolean8(debug='border_anim_drawn')
        for j in range(0, 19):
            for k in range(0, 12):
                data.uint16(debug="border_elevation_sprite_frames {} {}".format(j, k))  # frames
                data.uint16(debug="border_elevation_sprite_facets {} {}".format(j, k))  # facets
                data.uint16(debug="border_elevation_sprite_rame_id {} {}".format(j, k))  # frame_id

        data.int8(debug='border_draw_tile')
        data.uint8(debug='padding')
        data.int16(debug='border_underlay_terrain')
        data.int16(debug='border_style')
        return TerrainBorder()
Ejemplo n.º 9
0
 def read(data: ScnDataReader, sprite_id):
     sprite_name = data.string_fixed(21, debug='sprite_name')
     sprite_filename = data.string_fixed(13, debug='sprite_filename')
     sprite_slp_id = data.uint32(debug='sprite_slp_id')
     sprite_is_loaded = data.boolean8(debug='sprite_is_loaded')
     sprite_color_flag = data.boolean8(debug='sprite_color_flag')
     sprite_layer = data.uint8(debug='sprite_layer')
     sprite_color_table = data.int16(debug='sprite_color_table')
     sprite_transparent_selection = data.boolean8(
         debug='sprite_transparent_selection')
     sprite_bounding_box = (
         data.int16(),  # X1
         data.int16(),  # Y1
         data.int16(),  # X2
         data.int16())  # Y2
     sprite_num_deltas = data.uint16(debug='sprite_num_deltas')
     sprite_sound_id = data.int16(debug='sprite_sound_id')
     attack_sounds_used = data.boolean8()
     sprite_num_frames = data.uint16()
     sprite_num_facets = data.uint16()
     sprite_base_speed = data.float32()
     sprite_frame_rate = data.float32()
     sprite_replay_delay = data.float32()
     sprite_sequence_type = data.uint8()
     sprite_other_id = data.uint16(debug='sprite_other_id')
     sprite_mirror_flag = data.uint8()
     # sprite_other_flag = data.uint8() # Reading 1 byte too far here, one of these must not be in the AOE1 file.
     sprite_deltas = [
         SpriteDelta.read(data) for _ in range(0, sprite_num_deltas)
     ]
     facets = [SpriteFacet.read(data) for _ in range(0, sprite_num_facets)
               ] if attack_sounds_used else []
     return Sprite(sprite_id, sprite_name, sprite_filename, sprite_slp_id,
                   sprite_is_loaded, sprite_color_flag, sprite_layer,
                   sprite_color_table, sprite_transparent_selection,
                   sprite_bounding_box, sprite_sound_id, attack_sounds_used,
                   sprite_num_frames, sprite_num_facets, sprite_base_speed,
                   sprite_frame_rate, sprite_replay_delay,
                   sprite_sequence_type, sprite_other_id,
                   sprite_mirror_flag, sprite_deltas, facets)
Ejemplo n.º 10
0
def load(data: ScnDataReader):
    # Terrain
    data.mark(name='terrain')
    # num_terrains_override = num_terrains
    num_terrains_override = 32
    for i in range(0, num_terrains_override):
        data.boolean8(debug='terrain_enabled {}'.format(i))
        data.uint8(debug='terrain_random {}'.format(i))  # always 0?
        data.string_fixed(size=13, debug='terrain_name {}'.format(i))
        data.string_fixed(size=13, debug='terrain_texture_name {}'.format(
            i))  # Maybe read as int and test agains -1?
        data.int32(debug='terrain_slp_id {}'.format(i))
        data.int32(debug='terrain_slp_pointer {}'.format(i))
        data.int32(debug='terrain_sound_id {}'.format(i))
        data.uint8(debug='terrain_minimap_color_high {}'.format(
            i))  #  These colors are off-by-one compared with AGE.
        data.uint8(debug='terrain_minimap_color_medium {}'.format(i))
        data.uint8(debug='terrain_minimap_color_low {}'.format(i))
        data.uint8(debug='terrain_minimap_color_cliff_lt {}'.format(i))
        data.uint8(debug='terrain_minimap_color_cliff_rt {}'.format(i))
        data.int8(debug='terrain_passable_id {}'.format(i))
        data.int8(debug='terrain_impassable_id {}'.format(i))
        # Animation
        data.boolean8(debug='terrain_animation_enabled {}'.format(i))
        data.int16(debug='terrain_anim_num_frames {}'.format(i))
        data.int16(debug='terrain_anim_num_pause_frames {}'.format(i))
        data.float32(debug='terrain_anim_frame_interval {}'.format(i))
        data.float32(debug='terrain_anim_replay_delay {}'.format(i))
        data.int16(debug='terrain_anim_frame {}'.format(i))
        data.int16(debug='terrain_anim_draw_frame {}'.format(i))
        data.float32(debug='terrain_anim_animate_last {}'.format(i))
        data.boolean8(debug='terrain_anim_frame_changed {}'.format(i))
        data.boolean8(debug='terrain_anim_drawn {}'.format(i))
        # Elevation sprites
        for j in range(0, 19):
            data.uint16(debug="terrain_elevation_sprite_frames {} {}".format(
                i, j))  # frames
            data.uint16(debug="terrain_elevation_sprite_facets {} {}".format(
                i, j))  # facets
            data.uint16(debug="terrain_elevation_sprite_frame_id {} {}".format(
                i, j))  # frame_id
        data.int16(debug="terrain_to_draw {}".format(i))
        data.uint16(debug="terrain_rows {}".format(i))
        data.uint16(debug="terrain_cols {}".format(i))
        # Borders
        for j in range(0, num_terrains_override):
            data.uint16(debug="terrain_border {} {}".format(i, j))

        # Objects
        for j in range(0, 30):
            data.uint16(debug="terrain_object_id {} {}".format(i, j))
        for j in range(0, 30):
            data.int16(debug="terrain_density {} {}".format(i, j))
        for j in range(0, 30):
            data.int8(debug="terrain_placement_flag {} {}".format(
                i, j))  # 0 for random, 1 for central

        data.uint16(debug="terrain_object_count {}".format(i))
        data.uint16(debug="padding {}".format(i))
    return []
Ejemplo n.º 11
0
def load(data: ScnDataReader) -> List[TerrainTable]:
    # Read the terrain tables
    data.mark(name='terrain tables')
    num_terrain_tables = data.uint16(debug='num_terrain_tables')
    num_terrains = data.uint16(debug='num_terrains')
    unknown_values = []
    for terrain_table_id in range(0, num_terrain_tables):
        unknown_value = data.uint32(
            debug="terrain table {} unknown value".format(terrain_table_id))
        unknown_values.append(unknown_value)
    terrain_tables = []
    for terrain_table_id in range(0, num_terrain_tables):
        passable = [
            data.float32("passability table={} terrain={}".format(
                terrain_table_id, terrain_id))
            for terrain_id in range(0, num_terrains)
        ]
        terrain_tables.append(
            TerrainTable(unknown_values[terrain_table_id], passable))
    return terrain_tables
Ejemplo n.º 12
0
 def read_de(data: ScnDataReader, player_version: float):
     return WorldPlayer(
         data.float32(debug='food'), data.float32(debug='wood'),
         data.float32(debug='gold'), data.float32(debug='stone'), 0, 0,
         data.float32(
             debug='population') if player_version >= 3.13 else 75.0)
Ejemplo n.º 13
0
    def read_classic(data: ScnDataReader):
        # TODO actually store this stuff
        version = data.float32(debug='version')
        if version > 1.13:
            for i in range(0, 16):
                # skip past player names
                player_name = data.string_fixed(size=256)

        if version > 1.16:
            raise Exception("Not implemented: player string table not understood")

        if version > 1.13:
            for i in range(0, 16):
                player_base = ScnPlayerBaseProperties.read(data)
                logging.debug(player_base)

        is_conquest = False
        if version > 1.07:
            is_conquest = data.boolean8()

        # Something to do with timelines?
        check1 = data.uint16()
        check2 = data.uint16()
        check3 = data.float32()
        if check1 != 0 or check2 != 0 or check3 < -1 or check3 > 1:
            raise Exception("Unexpected values in scenario data, giving up")

        filename = data.string16(debug='filename')

        if version > 1.16:
            raise Exception("Not implemented: scenario instruction string table not understood")

        if version > 1.22:
            raise Exception("Not implemented: scout string table not understood")

        description = data.string16(debug='description')

        if version >= 1.11:
            hints_message = data.string16(debug='hints_message')
            win_message = data.string16(debug='win_message')
            loss_message = data.string16(debug='loss_message')
            history_message = data.string16(debug='history_message')

        if version > 1.22:
            raise Exception("Not implemented: scout data not understood")

        pregame_cinematic = data.string16(debug='pregame_cinematic')
        victory_cinematic = data.string16(debug='victory_cinematic')
        loss_cinematic = data.string16(debug='loss_cinematic')

        if version >= 1.09:
            mission_bmp = data.string16()
            logging.debug("mission_bmp='%s'", mission_bmp)

        if version >= 1.10:
            mission_image = data.uint32()
            width = data.uint32()
            height = data.uint32()
            orientation = data.uint16()
            if width > 0 or height > 0:
                raise Exception("Mission BMP data not understood")

        for i in range(0, 16):
            player_build_list = data.string16()
            logging.debug("Player %d build list %s", i, player_build_list)

        for i in range(0, 16):
            player_city_plan = data.string16()
            logging.debug("Player %d city plan %s", i, player_city_plan)

        if version >= 1.08:
            for i in range(0, 16):
                player_personality = data.string16()
                logging.debug("Player %d personality %s", i, player_personality)

        for i in range(0, 16):
            """ Embedded files """
            build_list_length = data.uint32()
            city_plan_length = data.uint32()
            ai_rules_length = data.uint32() if version >= 1.08 else 0
            data.read(build_list_length)
            data.read(city_plan_length)
            data.read(ai_rules_length)

        if version >= 1.20:
            raise Exception("Not implemented: AI rules not understood")

        if version >= 1.02:
            check4 = data.int32()
            if check4 != -99:
                raise Exception("Check value did not match in scenario data, giving up")

        rge_scen = ScnEngineProperties(
            version
        )
        logging.debug(rge_scen)
        return rge_scen
Ejemplo n.º 14
0
    def read_de(data: ScnDataReader):
        version = data.float32(debug='version')

        for i in range(0, 16):
            data.uint16(debug='some number here')  # 2656
            data.string16(debug='player tribe name')

        if version >= 3.13:
            # These 16 bytes are not present in some DE scenarios bundled w/ the game, labelled version 3.125.
            for i in range(0, 16):
                # Guessing its a string ref, have not checked
                data.int32(debug="unknown_string_ref for player {}".format(i))

        for i in range(0, 16):
            player_base_props = ScnPlayerBaseProperties.read(data)
            logging.debug(player_base_props)

        data.boolean32(debug='conquest maybe')
        data.float32(debug='probable check field')

        data.uint8(debug='unknown field')

        data.uint16(debug='some number here')  # 2656
        data.string16(debug='scenario_name')

        data.uint16(debug='some number here')  # 2656
        data.string16(debug='scenario_instructions')

        data.uint16(debug='some number here')  # 2656
        data.string16(debug='history_string')

        data.uint16(debug='some number here')  # 2656
        data.string16(debug='victory_string')

        data.uint16(debug='some number here')  # 2656
        data.string16(debug='loss_string')

        data.uint16(debug='some number here')  # 2656
        data.string16(debug='history_string')

        data.int32(debug='instructions_string_reference')
        data.uint16(debug='some_number_here')  # 2656
        data.string16(debug='instructions_vox')

        data.int32(debug='hints_string_reference')
        data.uint16(debug='some_number_here')  # 2656
        data.string16(debug='hints_vox')

        data.int32(debug='victory_string_reference')
        data.uint16(debug='some_number_here')  # 2656
        data.string16(debug='victory_vox')

        data.int32(debug='loss_string_reference')
        data.uint16(debug='some_number_here')  # 2656
        data.string16(debug='loss_vox')

        data.int32(debug='history_string_reference')
        data.uint16(debug='some_number_here')  # 2656
        data.string16(debug='history_vox')

        # Not sure if cinematics or per-player personality, AI, city plans etc

        data.uint16(debug='some_number_here')  # 2656
        data.string16(debug='unidentified_string 1')  # ' <None> '

        data.uint16(debug='some_number_here')  # 2656
        data.string16(debug='unidentified_string 2')  # ' <None> '

        data.uint16(debug='some_number_here')  # 2656
        data.string16(debug='unidentified_string 3')  # ' <None> '

        data.uint16(debug='some_number_here')  # 2656
        data.string16(debug='unidentified_string 4')  # ' <None> '

        data.uint32(debug='unidentified number 1')  # 0
        data.uint32(debug='unidentified number 2')  # 0
        data.uint32(debug='unidentified number 3')  # 0
        data.uint16(debug='unidentified number 4')  # 1

        for i in range(0, 16):
            data.string16(debug="ai player {}".format(i))

        for i in range(0, 16):
            data.string16(debug="city plan player {}".format(i))

        for i in range(0, 16):
            data.string16(debug="personality player {}".format(i))

        for i in range(0, 16):
            some_length1 = data.uint32(debug='some length maybe')
            some_length2 = data.uint32(debug='some length maybe')
            some_length3 = data.uint32(debug='some length maybe')
            data.string_fixed(some_length1, debug='some string 1')
            data.string_fixed(some_length2, debug='some string 2')
            data.string_fixed(some_length3, debug='some string 3')

        check1 = data.int32(debug='check value 1')
        if check1 != -99:
            raise Exception("Check value did not match in scenario data, giving up")

        if version < 3.13:
            data.mark('extra data observed in 3.125 version')
            for i in range(0, 32):
                data.int32(debug='unknown value 1 {}'.format(i))  # 500
            for i in range(0, 32):
                data.int32(debug='unknown value 2 {}'.format(i))  # 0

        check2 = data.int32(debug='check value 2')
        if check2 != -99:
            raise Exception("Check value did not match in scenario data, giving up")

        rge_scen = ScnEngineProperties(
            version
        )
        logging.debug(rge_scen)
        return rge_scen
Ejemplo n.º 15
0
 def read_de(data: ScnDataReader):
     return ScenarioObject((data.float32(), data.float32(), data.float32()),
                           data.uint32(), data.uint16(), data.uint8(),
                           data.float32(), -1, -1)
Ejemplo n.º 16
0
def read_base_unit_props(data: ScnDataReader):
    data.mark("base unit")
    unit_name_len = data.uint16(debug='unit_name_len')
    unit_id = data.int16(debug='unit_id')
    unit_name_string_id = data.int16(debug='unit_name_string_id')
    unit_creation_string_id = data.int16(debug='unit_creation_string_id')
    unit_class = data.int16(debug='unit_class')
    standing_sprite = data.int16(
        debug='standing_sprite')  # no standing sprite #2 here.. ?
    dying_sprite = data.int16(debug='dying_sprite')
    undead_sprite = data.int16(debug='undead_sprite')
    undead_flag = data.int8(debug='undead_flag')
    hp = data.uint16(debug='hp')
    los = data.float32(debug='los')
    garrison_capacity = data.uint8(debug='garrison_capacity')
    collision_radius = (data.float32(debug='collision_radius1'),
                        data.float32(debug='collision_radius2'),
                        data.float32(debug='collision_radius3'))
    unit_train_sound = data.int16(debug='train_sound')
    # unit_damage_sound = data.int16(debug='damage_sound')
    unit_death_spawn = data.int16(
        debug='unit_death_spawn')  # no unit_damage_sound here ??
    unit_sort_number = data.uint8(debug='unit_sort_number')
    unit_can_be_built_on = data.uint8(debug='unit_can_be_built_on')
    unit_button_picture = data.int16(debug='unit_button_picture')
    unit_hide_in_scenario_editor = data.boolean8(
        debug='unit_hide_in_scenario_editor')
    unit_portrait_picture = data.int16(debug='unit_portrait_picture')
    unit_enabled = data.boolean8(
        debug='unit_enabled')  # no unit_disabled here ??
    unit_tile_req = (data.int16(debug='unit_tile_req1'),
                     data.int16(debug='unit_tile_req2')
                     )  # "Placement side terrains"
    unit_center_tile_req = (data.int16(debug='unit_center_tile_req1'),
                            data.int16(debug='unit_center_tile_req1'))
    unit_construction_radius = (data.float32(
        debug='unit_construction_radius1'),
                                data.float32(
                                    debug='unit_construction_radius2'))
    unit_elevation_flag = data.boolean8(debug='unit_elevation_flag')
    unit_fog_flag = data.boolean8(debug='unit_fog_flag')
    unit_terrain_restriction_id = data.uint16(
        debug='unit_terrain_restriction_id')  # "terrain tables"
    unit_movement_type = data.uint8(debug='unit_movement_type')
    unit_attribute_max_amount = data.uint16(
        debug='unit_attribute_max_amount')  # resource capacity
    unit_attribute_rot = data.float32(debug='unit_attribute_rot')  # decay
    unit_area_effect_level = data.uint8(debug='unit_area_effect_level')
    unit_combat_level = data.uint8(debug='unit_combat_level')
    unit_select_level = data.uint8(debug='unit_select_level')
    unit_map_draw_level = data.uint8(debug='unit_map_draw_level')
    unit_level = data.uint8(debug='unit_level')
    unit_multiple_attribute_mod = data.float32(
        debug='unit_multiple_attribute_mod')
    unit_map_color = data.uint8(debug='unit_map_color')
    unit_help_string_id = data.uint32('unit_help_string_id')
    unit_help_page_id = data.uint32(debug='unit_help_page_id')
    unit_hotkey_id = data.uint32(debug='unit_hotkey_id')
    unit_recyclable = data.boolean8(debug='unit_recyclable')
    unit_track_as_resource = data.boolean8(debug='unit_track_as_resource')
    unit_create_doppleganger = data.boolean8(debug='unit_create_doppleganger')
    unit_resource_group = data.uint8(
        debug='unit_resource_group')  # tree/stone/gold etc
    unit_occlusion_mask = data.uint8(
        debug='unit_occlusion_mask')  # "hill mode" in AGE
    unit_obstruction_type = data.uint8(
        debug='unit_obstruction_type'
    )  # dropped unit_selection_shape, unit_civilization, unit_attribute_piece
    # # object flags go here in later versions
    selection_outline_radius = (
        data.float32(debug='selection_outline_radius1'),
        data.float32(debug='selection_outline_radius2'),
        data.float32(debug='selection_outline_radius3'))
    for i in range(0, 3):
        attribute_res = data.int16(debug='attribute_res {}'.format(i))
        attribute_amount = data.float32(debug='attribute_amount {}'.format(i))
        attribute_store_mode = data.int8(
            debug='attribute_store_mode {}'.format(i))
    num_damage_sprites = data.uint8(debug='num_damage_sprites')
    for i in range(0, num_damage_sprites):
        damage_sprite = data.uint16(debug='damage_sprite {}'.format(i))
        damage_percent = data.uint8(debug='damage_percent {}'.format(i))
        damage_apply_mode = data.uint8(debug='damage_apply_mode {}'.format(i))
        damage_unused = data.uint8(debug='damage_unused {}'.format(i))
    unit_selected_sound = data.int16(debug='unit_selected_sound')
    unit_death_sound = data.int16(debug='unit_death_sound')
    unit_attack_reaction = data.uint8(debug='unit_attack_reaction')
    unit_convert_terrain_flag = data.uint8(debug='unit_convert_terrain_flag')
    unit_name = data.string_fixed(size=unit_name_len, debug='unit_name')
    data.uint16(debug='unit_copy_id')  # dropped unit_copy_id, unit_group
    return unit_name