public TagClass(ITagClass baseClass, string name, string description)
{
RawClass = baseClass;
TagClassMagic = name;
Description = description;
Children = new List <TagEntry>();
}
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;
}
public FourthGenTag(DatumIndex index, ITagClass tagClass, SegmentPointer headerLocation, SegmentPointer metaLocation)
{
Index = index;
Class = tagClass;
MetaLocation = metaLocation;
HeaderLocation = headerLocation;
}
public DupeSettings(ICacheFile cache, ITagClass tagClass, string origName)
{
InitializeComponent();
_cacheFile = cache;
_tagClass = tagClass;
_origName = origName;
NewName = origName;
tagName.Text = origName;
tagName.Focus();
tagName.SelectAll();
}
/// <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);
}
/// <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);
}
public ThirdGenTag(DatumIndex index, ITagClass tagClass, SegmentPointer metaLocation)
{
Index = index;
Class = tagClass;
MetaLocation = metaLocation;
}
public FourthGenTag(DatumIndex index, ITagClass tagClass, SegmentPointer headerLocation, SegmentPointer metaLocation)
{
Index = index;
Class = tagClass;
MetaLocation = metaLocation;
HeaderLocation = headerLocation;
}
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
}
public ThirdGenTag(DatumIndex index, ITagClass tagClass, SegmentPointer metaLocation)
{
Index = index;
Class = tagClass;
MetaLocation = metaLocation;
}
/// <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));
}
/// <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));
}
/// <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));
}
/// <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));
}