Esempio n. 1
0
 public TagClass(ITagClass baseClass, string name, string description)
 {
     RawClass      = baseClass;
     TagClassMagic = name;
     Description   = description;
     Children      = new List <TagEntry>();
 }
Esempio n. 2
0
 public TagClass(ITagClass baseClass, string name, string description)
 {
     RawClass = baseClass;
     TagClassMagic = name;
     Description = description;
     Children = new List<TagEntry>();
 }
 public NewThirdGenTag(DatumIndex index, ITagClass tagClass, SegmentPointer metaLocation, uint virtualAddr)
 {
     Index        = index;
     Class        = tagClass;
     MetaLocation = metaLocation;
     VirtualAddr  = virtualAddr;
 }
Esempio n. 4
0
 public FourthGenTag(DatumIndex index, ITagClass tagClass, SegmentPointer headerLocation, SegmentPointer metaLocation)
 {
     Index          = index;
     Class          = tagClass;
     MetaLocation   = metaLocation;
     HeaderLocation = headerLocation;
 }
Esempio n. 5
0
        public DupeSettings(ICacheFile cache, ITagClass tagClass, string origName)
        {
            InitializeComponent();

            _cacheFile = cache;
            _tagClass  = tagClass;
            _origName  = origName;
            NewName    = origName;

            tagName.Text = origName;

            tagName.Focus();
            tagName.SelectAll();
        }
Esempio n. 6
0
        /// <summary>
        ///     Adds a tag to the table and allocates space for its base data.
        /// </summary>
        /// <param name="classMagic">The magic number (ID) of the tag's class.</param>
        /// <param name="baseSize">The size of the data to initially allocate for the tag.</param>
        /// <param name="stream">The stream to write to.</param>
        /// <returns>
        ///     The tag that was allocated.
        /// </returns>
        public override ITag AddTag(int classMagic, int baseSize, IStream stream)
        {
            /*
             *          //if (_indexHeaderLocation == null)
             *          //	throw new InvalidOperationException("Tags cannot be added to a shared map");
             *
             *          ITagClass tagClass = Classes.FirstOrDefault(c => (c.Magic == classMagic));
             *          if (tagClass == null)
             *                  throw new InvalidOperationException("Invalid tag class");
             *
             *          uint address = _allocator.Allocate(baseSize, stream);
             *          var index = new DatumIndex(0x4153, (ushort) _tags.Count); // 0x4153 = 'AS' because the salt doesn't matter
             * var result = new FourthGenTag(index, tagClass, (uint)stream.Position);
             *          _tags.Add(result);
             *
             *          return result;
             * */

            ITagClass tagClass = Classes.FirstOrDefault(c => (c.Magic == classMagic));

            if (tagClass == null)
            {
                throw new InvalidOperationException("Invalid tag class");
            }

            var  offset  = stream.BaseStream.Position;
            uint address = _allocator.Allocate(baseSize, stream);
            var  index   = new DatumIndex(0x4153, (ushort)_tags.Count); // 0x4153 = 'AS' because the salt doesn't matter

            // File Segment
            FileSegmenter segmenter = new FileSegmenter();

            segmenter.DefineSegment(0, (int)stream.Length, 0x4, SegmentResizeOrigin.Beginning); // Define a segment for the header
            //_eofSegment = segmenter.WrapEOF((int)map_values.GetInteger("file size"));
            FileSegment      segment      = new FileSegment(0, segmenter);
            FileSegmentGroup segmentgroup = new FileSegmentGroup();

            SegmentPointer pointer = new SegmentPointer(segment, segmentgroup, (int)offset);
            FourthGenTag   result  = new FourthGenTag(index, tagClass, pointer, pointer);

            _tags.Add(result);

            return(result);
        }
Esempio n. 7
0
        /// <summary>
        ///     Adds a tag to the table and allocates space for its base data.
        /// </summary>
        /// <param name="classMagic">The magic number (ID) of the tag's class.</param>
        /// <param name="baseSize">The size of the data to initially allocate for the tag.</param>
        /// <param name="stream">The stream to write to.</param>
        /// <returns>
        ///     The tag that was allocated.
        /// </returns>
        public override ITag AddTag(int classMagic, int baseSize, IStream stream)
        {
            if (_indexHeaderLocation == null)
            {
                throw new InvalidOperationException("Tags cannot be added to a shared map");
            }

            ITagClass tagClass = Classes.FirstOrDefault(c => (c.Magic == classMagic));

            if (tagClass == null)
            {
                throw new InvalidOperationException("Invalid tag class");
            }

            uint address = _allocator.Allocate(baseSize, stream);
            var  index   = new DatumIndex(0x4153, (ushort)_tags.Count);           // 0x4153 = 'AS' because the salt doesn't matter
            var  result  = new ThirdGenTag(index, tagClass, SegmentPointer.FromPointer(address, _metaArea));

            _tags.Add(result);

            return(result);
        }
Esempio n. 8
0
 public ThirdGenTag(DatumIndex index, ITagClass tagClass, SegmentPointer metaLocation)
 {
     Index        = index;
     Class        = tagClass;
     MetaLocation = metaLocation;
 }
Esempio n. 9
0
		public FourthGenTag(DatumIndex index, ITagClass tagClass, SegmentPointer headerLocation, SegmentPointer metaLocation)
		{
			Index = index;
			Class = tagClass;
			MetaLocation = metaLocation;
			HeaderLocation = headerLocation;
		}
Esempio n. 10
0
        private List <ITag> LoadTags(IReader reader, StructureValueCollection headerValues, IList <ITagClass> classes)
        {
            /*
             * StructureLayout layout = _buildInfo.Layouts.GetLayout("tag entry");
             *          StructureValueCollection[] entries = ReflexiveReader.ReadReflexive(reader, count, address, layout, _metaArea);
             *          return
             *                  entries.Select<StructureValueCollection, ITag>((e, i) => new FourthGenTag(e, (ushort) i, _metaArea, classes))
             *                          .ToList();
             */

            List <ITag> tags = new List <ITag>(); // New list of tags

            reader.SeekTo(0);
            var             count   = (int)headerValues.GetInteger("number of tags");
            uint            address = headerValues.GetInteger("tag table address");
            StructureLayout layout  = _buildInfo.Layouts.GetLayout("tag entry");

            // File Segment
            FileSegmenter segmenter = new FileSegmenter();

            segmenter.DefineSegment(0, (int)reader.Length, 0x4, SegmentResizeOrigin.Beginning); // Define a segment for the header
            //_eofSegment = segmenter.WrapEOF((int)map_values.GetInteger("file size"));
            FileSegment      segment      = new FileSegment(0, segmenter);
            FileSegmentGroup segmentgroup = new FileSegmentGroup();

            // Find all of the tag offsets
            reader.BaseStream.Position = address; // Start at the beginning og the offsets
            List <uint> tagOffsets = new List <uint>();

            for (int i = 0; i < count; i++)
            {
                tagOffsets.Add(reader.ReadUInt32());
            }

            reader.BaseStream.Position = tagOffsets[0];
            for (int i = 0; i < count; i++) // Loop through each offset
            {
                //if (tagOffsets[i] == 0) tags.Add(null);
                //else
                if (tagOffsets[i] != 0)
                {
                    //var headerOffset = (uint)reader.BaseStream.Position;

                    /*
                     * var checksum = reader.ReadUInt32();                         // 0x00 uint32 checksum?
                     * var totalSize = reader.ReadUInt32();                        // 0x04 uint32 total size
                     * var numDependencies = reader.ReadInt16();                   // 0x08 int16  dependencies count
                     * var numDataFixups = reader.ReadInt16();                     // 0x0A int16  data fixup count
                     * var numResourceFixups = reader.ReadInt16();                 // 0x0C int16  resource fixup count
                     * reader.BaseStream.Position += 2;                            // 0x0E int16  (padding)
                     * var mainStructOffset = reader.ReadUInt32();                 // 0x10 uint32 main struct offset
                     * var tagClass = reader.ReadInt32();                          // 0x14 int32  class
                     * var parentClass = reader.ReadInt32();                       // 0x18 int32  parent class
                     * var grandparentClass = reader.ReadInt32();                  // 0x1C int32  grandparent class
                     * var classId = reader.ReadUInt32();                          // 0x20 uint32 class stringid
                     */
                    /*
                     *
                     * reader.BaseStream.Position = tagOffsets[i];
                     * StructureValueCollection tag_entry_values = StructureReader.ReadStructure(reader, layout);
                     * uint id = tag_entry_values.GetInteger("magic");
                     * if(id == 0x3c66783e )
                     * {
                     *  uint x = id;
                     * }
                     * //ITagClass tagclass = TryAddClass(tag_entry_values);
                     * //FourthGenTag tag = new FourthGenTag(new DatumIndex(headerOffset), tagclass, headerOffset);
                     *
                     * uint tag_offset = tagOffsets[i];
                     * //SegmentPointer pointer = new SegmentPointer(segment, segmentgroup, (int)tag_offset);
                     *
                     * uint dep_size = (tag_entry_values.GetInteger("dependencies count") * 4 + tag_entry_values.GetInteger("data fixups count") * 4 + tag_entry_values.GetInteger("resource fixups count") * 4);
                     * tag_offset += tag_entry_values.GetInteger("total size") - (tag_entry_values.GetInteger("main struct offset") + dep_size);
                     *
                     * ITagClass tagclass = TryAddClass(tag_entry_values);
                     * //FourthGenTag tag = new FourthGenTag(new DatumIndex(headerOffset), tagclass, headerOffset);
                     *
                     * SegmentPointer pointer = new SegmentPointer(segment, segmentgroup, (int)(tag_offset));
                     *
                     * FourthGenTag tag = new FourthGenTag(new DatumIndex(tag_offset), tagclass, pointer);
                     * tags.Add(tag);
                     * */

                    var headerOffset = tagOffsets[i];
                    reader.BaseStream.Position = headerOffset;

                    StructureValueCollection tag_entry_values = StructureReader.ReadStructure(reader, layout);

                    reader.BaseStream.Position = tagOffsets[i] + 0x24;

                    int structOffset = (int)tag_entry_values.GetInteger("main struct offset");
                    int metaOffset   = (int)tagOffsets[i] + structOffset;

                    ITagClass tagclass = TryAddClass(tag_entry_values);

                    //SegmentPointer pointer = new SegmentPointer(segment, segmentgroup, metaOffset);
                    //FourthGenTag tag = new FourthGenTag(new DatumIndex((uint)i), tagclass, pointer);
                    SegmentPointer hdrPointer = new SegmentPointer(segment, segmentgroup, (int)headerOffset);
                    SegmentPointer pointer    = new SegmentPointer(segment, segmentgroup, metaOffset);
                    FourthGenTag   tag        = new FourthGenTag(new DatumIndex((uint)i), tagclass, hdrPointer, pointer);
                    tags.Add(tag);
                }
                else // Null Tag
                {
                    FourthGenTag tag = new FourthGenTag(new DatumIndex((uint)i), null, null, null);
                    tags.Add(tag);
                }
            }

            return(tags.Where(t => t != null).ToList()); // Remove NULL Entries
        }
Esempio n. 11
0
 public ThirdGenTag(DatumIndex index, ITagClass tagClass, SegmentPointer metaLocation)
 {
     Index = index;
     Class = tagClass;
     MetaLocation = metaLocation;
 }
Esempio n. 12
0
 /// <summary>
 ///     Adds a tag to the table and allocates space for its base data.
 /// </summary>
 /// <param name="tagClass">The tag's class.</param>
 /// <param name="baseSize">The size of the data to initially allocate for the tag.</param>
 /// <param name="stream">The stream to write to.</param>
 /// <returns>The tag that was added.</returns>
 public ITag AddTag(ITagClass tagClass, int baseSize, IStream stream)
 {
     return(AddTag(tagClass.Magic, baseSize, stream));
 }
Esempio n. 13
0
 /// <summary>
 ///     Finds the first tag in a class which has a given name.
 /// </summary>
 /// <param name="name">The case-sensitive tag name to search for.</param>
 /// <param name="tagClass">The tag class to search in.</param>
 /// <param name="names">The <see cref="FileNameSource" /> containing tag names.</param>
 /// <returns>The first tag in the class which has the given name, or null if nothing was found.</returns>
 public ITag FindTagByName(string name, ITagClass tagClass, FileNameSource names)
 {
     return(FindTagByName(name, tagClass.Magic, names));
 }
Esempio n. 14
0
 /// <summary>
 ///     Retrieves a collection of tags which are members of a given class.
 ///     Tags which inherit from the class will be included as well.
 /// </summary>
 /// <param name="tagClass">The tag class to search for.</param>
 /// <returns>A collection of tags which are members of the class.</returns>
 public IEnumerable <ITag> FindTagsByClass(ITagClass tagClass)
 {
     return(FindTagsByClass(tagClass.Magic));
 }
Esempio n. 15
0
 /// <summary>
 ///     Finds the first tag which belongs to a given class.
 ///     Tags which inherit from the class will be included as well.
 /// </summary>
 /// <param name="tagClass">The tag class to search for.</param>
 /// <returns>The first tag which is a member of the class, or null if not found.</returns>
 public ITag FindTagByClass(ITagClass tagClass)
 {
     return(FindTagByClass(tagClass.Magic));
 }