private static IList<tag_field> ExtractFields(IEnumerable<tag_group> h2Tags, BinaryReader reader, tag_group tag)
 {
     reader.BaseStream.Position = tag.definition_address - Guerilla.BaseAddress;
     var definition = reader.ReadFieldDefinition<tag_block_definition>();
     tag_field_set field_set;
     return reader.ReadFieldSet(ref definition, out field_set);
 }
        public tag_group(BinaryReader reader)
            : this()
        {
            var stream = reader.BaseStream;

            this.name_address = reader.ReadInt32();
            this.flags = reader.ReadInt32();
            this.group_tag = reader.ReadInt32();
            this.parent_group_tag = reader.ReadInt32();
            this.version = reader.ReadInt16();
            this.initialized = reader.ReadByte();

            stream.Seek(1, SeekOrigin.Current);

            this.postprocess_proc = reader.ReadInt32();
            this.save_postprocess_proc = reader.ReadInt32();
            this.postprocess_for_sync_proc = reader.ReadInt32();

            stream.Seek(4, SeekOrigin.Current);

            this.definition_address = reader.ReadInt32();
            this.child_group_tags = new int[16];
            for (int i = 0; i < 16; i++)
                this.child_group_tags[i] = reader.ReadInt32();
            this.childs_count = reader.ReadInt16();

            stream.Seek(2, SeekOrigin.Current);

            this.default_tag_path_address = reader.ReadInt32();


            this.text = Guerilla.ReadString(reader, this.name_address);

            DefaultPath = Guerilla.ReadString(reader, this.default_tag_path_address);
            stream.Seek(this.definition_address, SeekOrigin.Begin);
            if (Class.ToString() == "snd!")
            {

                Definition = reader.ReadFieldDefinition<tag_block_definition>();
            }
            else
            {
                Definition = reader.ReadFieldDefinition<tag_block_definition>();
            }
        }
        public tag_field_set(BinaryReader reader, Action<BinaryReader, IList<tag_field>> postprocessFunction = null)
            : this()
        {
            this.version = reader.ReadFieldDefinition<s_tag_field_set_version>();
            this.size = reader.ReadInt32();
            this.alignment_bit = reader.ReadInt32();
            this.parent_version_index = reader.ReadInt32();
            this.fields_address = reader.ReadInt32();
            this.size_string_address = reader.ReadInt32();

            // Read the size_of string.
            this.size_string = Guerilla.ReadString(reader, this.size_string_address);

            ReadFields(reader, postprocessFunction);
        }
        public tag_struct_definition(BinaryReader reader)
            : this()
        {
            // Read all the fields from the stream.
            this.name_address = reader.ReadInt32();
            this.group_tag = reader.ReadInt32();
            this.display_name_address = reader.ReadInt32();
            this.block_definition_address = reader.ReadInt32();

            this.displayName = Guerilla.ReadString(reader, this.display_name_address);
            this.name = Guerilla.ReadString(reader, this.name_address);

            reader.BaseStream.Seek(block_definition_address, SeekOrigin.Begin);
            Definition = reader.ReadFieldDefinition<tag_block_definition>();
        }
 private dynamic ReadDefinition(BinaryReader reader)
 {
     switch (type)
     {
         case field_type._field_block:
             return reader.ReadFieldDefinition<tag_block_definition>(ref this);
         case field_type._field_struct:
             return reader.ReadFieldDefinition<tag_struct_definition>(ref this);
         case field_type._field_char_enum:
         case field_type._field_enum:
         case field_type._field_long_enum:
         case field_type._field_byte_flags:
         case field_type._field_word_flags:
         case field_type._field_long_flags:
             return reader.ReadFieldDefinition<enum_definition>(ref this);
         case field_type._field_tag_reference:
             return reader.ReadFieldDefinition<tag_reference_definition>(ref this);
         case field_type._field_data:
             return reader.ReadFieldDefinition<tag_data_definition>(ref this);
         default:
             return definition;
     }
 }