public FourthGenZoneSet(StructureValueCollection values, IReader reader, FileSegmentGroup metaArea)
{
_metaArea = metaArea;
Load(values, reader);
}
public ThirdGenSoundResourceGestalt(StructureValueCollection values, IReader reader, FileSegmentGroup metaArea, EngineDescription buildInfo)
{
Load(values, reader, metaArea, buildInfo);
}
/// <summary>
/// Serializes the header's values, storing them into a StructureValueCollection.
/// </summary>
/// <param name="localeArea">The locale area of the cache file. Can be null.</param>
/// <param name="localePointerMask">The value to add to locale pointers to translate them to file offsets.</param>
/// <returns>The resulting StructureValueCollection.</returns>
public StructureValueCollection Serialize(FileSegmentGroup localeArea)
{
var values = new StructureValueCollection();
values.SetInteger("file size", FileSize);
values.SetInteger("type", (uint)Type);
values.SetString("internal name", InternalName);
values.SetString("scenario path", ScenarioPath);
//values.SetInteger("xdk version", (uint) XDKVersion);
//AdjustPartitions();
//values.SetArray("partitions", SerializePartitions());
//RebuildInteropData(localeArea);
/*
* values.SetArray("offset masks", SectionOffsetMasks.Select(m =>
* {
* var result = new StructureValueCollection();
* result.SetInteger("mask", m);
* return result;
* }).ToArray());
*
* values.SetArray("sections", Sections.Select(s => s.Serialize()).ToArray());
* values.SetInteger("tag buffer offset", Sections[(int) FourthGenInteropSectionType.Tag].VirtualAddress);
*/
/*
* if (MetaArea != null)
* {
* values.SetInteger("virtual base address", MetaArea.BasePointer);
* values.SetInteger("index header address", IndexHeaderLocation.AsPointer());
* values.SetInteger("virtual size", (uint) MetaArea.Size);
* }
*/
if (StringBlockLocation != null)
{
values.SetInteger("string block offset", StringBlockLocation.AsPointer());
}
values.SetInteger("string table count", (uint)StringIDCount);
if (StringIDData != null)
{
values.SetInteger("string table size", (uint)StringIDData.Size);
values.SetInteger("string table offset", StringIDDataLocation.AsPointer());
}
if (StringIDIndexTableLocation != null)
{
values.SetInteger("string index table offset", StringIDIndexTableLocation.AsPointer());
}
if (StringArea != null)
{
values.SetInteger("string data size", (uint)StringArea.Size);
}
/*
* values.SetInteger("file table count", (uint) FileNameCount);
* if (FileNameData != null)
* {
* values.SetInteger("file table offset", FileNameDataLocation.AsPointer());
* values.SetInteger("file table size", (uint) FileNameData.Size);
* }
*
* if (FileNameIndexTableLocation != null)
* values.SetInteger("file index table offset", FileNameIndexTableLocation.AsPointer());
*/
if (localeArea != null)
{
values.SetInteger("locale data index offset", localeArea.BasePointer);
values.SetInteger("locale data size", (uint)localeArea.Size);
}
/*
* if (UnknownTableLocation != null)
* {
* values.SetInteger("unknown table count", (uint) UnknownCount);
* values.SetInteger("unknown table offset", UnknownTableLocation.AsPointer());
* }
* */
return(values);
}
internal Script(StructureValueCollection values, IReader reader, FileSegmentGroup metaArea, StringIDSource stringIDs,
EngineDescription buildInfo, IPointerExpander expander)
{
Load(values, reader, metaArea, stringIDs, buildInfo, expander);
}
public ThirdGenModelRegion(StructureValueCollection values, IReader reader, FileSegmentGroup metaArea,
EngineDescription buildInfo)
{
Load(values, reader, metaArea, buildInfo);
}
public SecondGenScenarioScriptFile(ITag scenarioTag, ITag scriptTag, string tagName, FileSegmentGroup metaArea,
StringIDSource stringIDs, EngineDescription buildInfo, IPointerExpander expander)
{
_scenarioTag = scenarioTag;
_expander = expander;
_scriptTag = scriptTag;
_stringIDs = stringIDs;
_metaArea = metaArea;
_buildInfo = buildInfo;
Name = tagName.Substring(tagName.LastIndexOf('\\') + 1) + ".hsc";
DefineScriptObjectTagBlocks();
}
public FourthGenResourceMetaLoader(EngineDescription buildInfo, FileSegmentGroup metaArea)
{
_buildInfo = buildInfo;
_metaArea = metaArea;
}
/// <summary>
/// Writes data to a reflexive, reallocating the original.
/// </summary>
/// <param name="entries">The entries to write.</param>
/// <param name="oldCount">The old count.</param>
/// <param name="oldAddress">The old address.</param>
/// <param name="layout">The layout of the data to write.</param>
/// <param name="metaArea">The meta area of the cache file.</param>
/// <param name="allocator">The cache file's meta allocator.</param>
/// <param name="stream">The stream to manipulate.</param>
/// <returns>The address of the new reflexive, or 0 if the entry list is empty and the reflexive was freed.</returns>
public static long WriteReflexive(ICollection <StructureValueCollection> entries, int oldCount, long oldAddress,
StructureLayout layout, FileSegmentGroup metaArea, MetaAllocator allocator, IStream stream)
{
return(WriteReflexive(entries, oldCount, oldAddress, entries.Count, layout, metaArea, allocator, stream));
}
private void LoadPlaybackParameters(StructureValueCollection values, IReader reader, FileSegmentGroup metaArea, EngineDescription buildInfo)
{
var count = (int)values.GetInteger("number of playback parameters");
var address = (uint)values.GetInteger("playback parameters table address");
var layout = buildInfo.Layouts.GetLayout("sound playback parameters");
var entries = TagBlockReader.ReadTagBlock(reader, count, address, layout, metaArea);
SoundPlaybackParameters = (from entry in entries
select new ThirdGenSoundPlaybackParameter(entry)).ToArray <ISoundPlaybackParameter>();
}
private void Load(StructureValueCollection values, FileSegmenter segmenter)
{
_eofSegment = segmenter.WrapEOF((int)values.GetInteger("file size"));
var metaOffset = (int)values.GetInteger("meta offset");
int tagTableSize = (int)values.GetInteger("tag data offset");
int tagDataSize = (int)values.GetInteger("tag data size");
var headSegment = new FileSegment(
segmenter.DefineSegment(metaOffset, tagTableSize, 0x1000, SegmentResizeOrigin.Beginning), segmenter);
var metaSize = (int)values.GetInteger("meta size");
int metaOffsetMask = (int)values.GetInteger("meta offset mask");
var metaSegment = new FileSegment(
segmenter.DefineSegment(metaOffset + tagTableSize, tagDataSize, 0x1000, SegmentResizeOrigin.End), segmenter);
MetaArea = new FileSegmentGroup(new MetaOffsetConverter(headSegment, (uint)metaOffsetMask));
IndexHeaderLocation = MetaArea.AddSegment(headSegment);
MetaArea.AddSegment(metaSegment);
Type = (CacheFileType)values.GetInteger("type");
var headerGroup = new FileSegmentGroup();
headerGroup.AddSegment(segmenter.WrapSegment(0, HeaderSize, 1, SegmentResizeOrigin.None));
StringIDCount = (int)values.GetInteger("string table count");
var sidDataSize = (int)values.GetInteger("string table size");
StringIDData = segmenter.WrapSegment((int)values.GetInteger("string table offset"), sidDataSize, 1,
SegmentResizeOrigin.End);
StringIDIndexTable = segmenter.WrapSegment((int)values.GetInteger("string index table offset"), StringIDCount * 4, 4,
SegmentResizeOrigin.End);
FileNameCount = (int)values.GetInteger("file table count");
var fileDataSize = (int)values.GetInteger("file table size");
FileNameData = segmenter.WrapSegment((int)values.GetInteger("file table offset"), fileDataSize, 1,
SegmentResizeOrigin.End);
FileNameIndexTable = segmenter.WrapSegment((int)values.GetInteger("file index table offset"), FileNameCount * 4, 4,
SegmentResizeOrigin.End);
InternalName = values.GetString("internal name");
ScenarioName = values.GetString("scenario name");
StringArea = new FileSegmentGroup();
StringArea.AddSegment(segmenter.WrapSegment((int)values.GetInteger("string block offset"), StringIDCount * 0x80, 0x80,
SegmentResizeOrigin.End));
StringArea.AddSegment(StringIDIndexTable);
StringArea.AddSegment(StringIDData);
StringArea.AddSegment(FileNameIndexTable);
StringArea.AddSegment(FileNameData);
StringIDIndexTableLocation = SegmentPointer.FromOffset(StringIDIndexTable.Offset, StringArea);
StringIDDataLocation = SegmentPointer.FromOffset(StringIDData.Offset, StringArea);
FileNameIndexTableLocation = SegmentPointer.FromOffset(FileNameIndexTable.Offset, StringArea);
FileNameDataLocation = SegmentPointer.FromOffset(FileNameData.Offset, StringArea);
LocaleArea = new FileSegmentGroup();
var rawTableOffset = (int)values.GetInteger("raw table offset");
var rawTableSize = (int)values.GetInteger("raw table size");
// It is apparently possible to create a cache without a raw table, but -1 gets written as the offset
if (rawTableOffset != -1)
{
RawTable = segmenter.WrapSegment(rawTableOffset, rawTableSize, 0x80, SegmentResizeOrigin.End);
}
Checksum = (uint)values.GetInteger("checksum");
// Set up a bogus partition table
Partitions = new Partition[1];
Partitions[0] = new Partition(SegmentPointer.FromOffset(MetaArea.Offset, MetaArea), (uint)MetaArea.Size);
}
/// <summary>
/// Rebuilds the interop data table in a cache file.
/// </summary>
/// <param name="localeArea">The localization area of the file.</param>
private void RebuildInteropData(FileSegmentGroup localeArea)
{
ThirdGenInteropSection debugSection = Sections[(int)ThirdGenInteropSectionType.Debug];
ThirdGenInteropSection rsrcSection = Sections[(int)ThirdGenInteropSectionType.Resource];
ThirdGenInteropSection tagSection = Sections[(int)ThirdGenInteropSectionType.Tag];
ThirdGenInteropSection localeSection = Sections[(int)ThirdGenInteropSectionType.Localization];
// Recompute base addresses
// Section addresses are usually in the following order: resource, locale, tag, debug.
// Each address can immediately follow after the previous non-null section,
// even though this isn't the case in some of the official files (because of removed debug data).
//
// TODO: This could possibly be made into a for loop and cleaned up if the pointer converters are stored in an array.
// I just want to get this working for now.
//rsrcSection.VirtualAddress = 0; // This is (not) always zero
rsrcSection.Size = (ResourcePointerConverter != null) ? (uint)RawTable.Size : 0;
localeSection.VirtualAddress = (LocalePointerConverter != null) ? rsrcSection.VirtualAddress + rsrcSection.Size : 0;
localeSection.Size = (LocalePointerConverter != null) ? (uint)localeArea.Size : 0;
tagSection.VirtualAddress = (TagBufferPointerConverter != null)
? rsrcSection.VirtualAddress + rsrcSection.Size + localeSection.Size
: 0;
tagSection.Size = (TagBufferPointerConverter != null) ? (uint)MetaArea.Size : 0;
debugSection.VirtualAddress = (DebugPointerConverter != null)
? rsrcSection.VirtualAddress + rsrcSection.Size + localeSection.Size + tagSection.Size
: 0;
debugSection.Size = (DebugPointerConverter != null) ? (uint)StringArea.Size : 0;
// If the offset mask for the debug section wasn't originally zero, then we have to subtract the first partition size from the debug base address
// Not entirely sure why this is the case, but that's what the official files do
if (debugSection.VirtualAddress != 0 && SectionOffsetMasks[(int)ThirdGenInteropSectionType.Debug] != 0)
{
debugSection.VirtualAddress -= Partitions[0].Size;
}
// Recompute offset masks
SectionOffsetMasks[(int)ThirdGenInteropSectionType.Debug] = (debugSection.Size > 0)
? (uint)(StringArea.Offset - debugSection.VirtualAddress)
: 0;
SectionOffsetMasks[(int)ThirdGenInteropSectionType.Resource] = (rsrcSection.Size > 0)
? (uint)(RawTable.Offset - rsrcSection.VirtualAddress)
: 0;
SectionOffsetMasks[(int)ThirdGenInteropSectionType.Tag] = (tagSection.Size > 0)
? (uint)(MetaArea.Offset - tagSection.VirtualAddress)
: 0;
SectionOffsetMasks[(int)ThirdGenInteropSectionType.Localization] = (localeSection.Size > 0)
? (uint)(localeArea.Offset - localeSection.VirtualAddress)
: 0;
// Update pointer converters
if (DebugPointerConverter != null)
{
DebugPointerConverter.BasePointer = debugSection.VirtualAddress;
}
if (ResourcePointerConverter != null)
{
ResourcePointerConverter.BasePointer = rsrcSection.VirtualAddress;
}
if (TagBufferPointerConverter != null)
{
TagBufferPointerConverter.BasePointer = tagSection.VirtualAddress;
}
if (LocalePointerConverter != null)
{
LocalePointerConverter.BasePointer = localeSection.VirtualAddress;
}
}
public FourthGenSimulationDefinitionTable(ITag scenario, TagTable tags, IReader reader, FileSegmentGroup metaArea, MetaAllocator allocator, EngineDescription buildInfo)
{
_scenario = scenario;
_tags = tags;
_metaArea = metaArea;
_allocator = allocator;
_buildInfo = buildInfo;
Load(reader);
}
public ThirdGenLanguageGlobals(StructureValueCollection values, FileSegmenter segmenter,
IPointerConverter localePointerConverter, EngineDescription buildInfo)
{
LocaleArea = new FileSegmentGroup(localePointerConverter);
Languages = LoadLanguages(values, segmenter, buildInfo);
}
public ThirdGenTag(StructureValueCollection values, ushort index, FileSegmentGroup metaArea,
IList<ITagGroup> groupList, IPointerExpander expander)
{
Load(values, index, metaArea, groupList, expander);
}
private void Load(StructureValueCollection values, ushort index, FileSegmentGroup header, FileSegmentGroup metaArea, IList <ITagClass> classList)
{
uint address = values.GetInteger("memory address");
if (address != 0 && address != 0xFFFFFFFF)
{
MetaLocation = SegmentPointer.FromPointer(address, metaArea);
HeaderLocation = SegmentPointer.FromPointer(address, header);
}
var classIndex = (int)values.GetInteger("class index");
if (classIndex >= 0 && classIndex < classList.Count)
{
Class = classList[classIndex];
}
var salt = (ushort)values.GetInteger("datum index salt");
if (salt != 0xFFFF)
{
Index = new DatumIndex(salt, index);
}
else
{
Index = DatumIndex.Null;
}
}
public SecondGenLanguageGlobals(StructureValueCollection values, FileSegmenter segmenter, EngineDescription buildInfo)
{
LocaleArea = new FileSegmentGroup();
Languages = LoadLanguages(values, segmenter, buildInfo);
}
public FirstGenTagTable(IReader reader, StructureValueCollection headerValues, FileSegmentGroup metaArea,
EngineDescription buildInfo)
{
Load(reader, headerValues, metaArea, buildInfo);
}
public FourthGenSound(StructureValueCollection values, IReader reader, FileSegmentGroup metaArea,
EngineDescription buildInfo)
{
Load(values, reader, metaArea, buildInfo);
}
public static StructureValueCollection[] ReadTagBlock(IReader reader, int count, long address,
StructureLayout elementLayout, FileSegmentGroup metaArea)
{
if (elementLayout.Size == 0)
{
throw new ArgumentException("The element layout must have a size associated with it.");
}
// Handle null pointers
if (count <= 0 || !metaArea.ContainsPointer(address))
{
return(new StructureValueCollection[0]);
}
// Convert the address to an offset and seek to it
int offset = metaArea.PointerToOffset(address);
reader.SeekTo(offset);
// Read the entries
var result = new StructureValueCollection[count];
for (int i = 0; i < count; i++)
{
result[i] = StructureReader.ReadStructure(reader, elementLayout);
}
return(result);
}
public RawData(string name, uint offset, string format, long address, string value, int length, uint pluginLine, string tooltip, FileSegmentGroup metaArea)
: base(name, offset, address, pluginLine, tooltip)
{
_value = value;
_length = length;
_format = format;
_metaArea = metaArea;
}
private void LoadVertexGroups(StructureValueCollection values, IReader reader, FileSegmentGroup metaArea,
EngineDescription buildInfo, IModelSubmesh[] submeshes)
{
var count = (int)values.GetInteger("number of vertex groups");
uint address = values.GetInteger("vertex group table address");
StructureLayout layout = buildInfo.Layouts.GetLayout("model vertex group");
StructureValueCollection[] entries = ReflexiveReader.ReadReflexive(reader, count, address, layout, metaArea);
VertexGroups = (from entry in entries
select new ThirdGenModelVertexGroup(entry, submeshes)).ToArray();
}
private void Load(StructureValueCollection values, FileSegmenter segmenter)
{
_eofSegment = segmenter.WrapEOF((int)values.GetInteger("file size"));
var metaOffset = (int)values.GetInteger("meta offset");
int metaSize;
if (values.HasInteger("tag data offset"))
{
metaSize = (int)values.GetInteger("tag data offset") + (int)values.GetInteger("tag data size");
}
else
{
metaSize = (int)values.GetInteger("meta size");
}
// store the stock meta size since xbox's size is virtual
//todo: figure out how this is calculated instead of doing a hack
_saved_meta_size_hack = (uint)values.GetInteger("meta size");
var metaSegment = new FileSegment(
segmenter.DefineSegment(metaOffset, metaSize, 0x4, SegmentResizeOrigin.Beginning), segmenter);
uint metaOffsetMask;
if (values.HasInteger("xbox meta offset mask"))
{
metaOffsetMask = (uint)values.GetInteger("xbox meta offset mask");
}
else
{
metaOffsetMask = (uint)(values.GetInteger("tag table offset") - values.GetInteger("meta header size"));
}
MetaArea = new FileSegmentGroup(new MetaOffsetConverter(metaSegment, metaOffsetMask));
IndexHeaderLocation = MetaArea.AddSegment(metaSegment);
Type = (CacheFileType)values.GetInteger("type");
var headerGroup = new FileSegmentGroup();
headerGroup.AddSegment(segmenter.WrapSegment(0, HeaderSize, 1, SegmentResizeOrigin.None));
//h2 alpha forcing this to be shoved in
if (values.HasInteger("string table count"))
{
StringIDCount = (int)values.GetInteger("string table count");
var sidDataSize = (int)values.GetInteger("string table size");
StringIDData = segmenter.WrapSegment((int)values.GetInteger("string table offset"), sidDataSize, 1,
SegmentResizeOrigin.End);
StringIDIndexTable = segmenter.WrapSegment((int)values.GetInteger("string index table offset"), StringIDCount * 4, 4,
SegmentResizeOrigin.End);
StringArea = new FileSegmentGroup();
if (values.HasInteger("string block offset"))
{
StringArea.AddSegment(segmenter.WrapSegment((int)values.GetInteger("string block offset"), StringIDCount * 0x80, 0x80,
SegmentResizeOrigin.End));
}
StringArea.AddSegment(StringIDIndexTable);
StringArea.AddSegment(StringIDData);
StringIDIndexTableLocation = SegmentPointer.FromOffset(StringIDIndexTable.Offset, StringArea);
StringIDDataLocation = SegmentPointer.FromOffset(StringIDData.Offset, StringArea);
}
else
{
//dummy
StringIDCount = 0;
StringIDData = _eofSegment;
StringIDIndexTable = _eofSegment;
}
InternalName = values.GetString("internal name");
Checksum = (uint)values.GetInteger("checksum");
// dummy partition
Partitions = new Partition[1];
Partitions[0] = new Partition(SegmentPointer.FromOffset(MetaArea.Offset, MetaArea), (uint)MetaArea.Size);
}
public ThirdGenZoneSet(StructureValueCollection values, IReader reader, FileSegmentGroup metaArea, IPointerExpander expander)
{
_metaArea = metaArea;
Load(values, reader, expander);
}
private void LoadBoundingBoxes(StructureValueCollection values, IReader reader, FileSegmentGroup metaArea,
EngineDescription buildInfo)
{
var count = (int)values.GetInteger("number of bounding boxes");
uint address = (uint)values.GetInteger("bounding box table address");
StructureLayout layout = buildInfo.Layouts.GetLayout("model bounding box");
StructureValueCollection[] entries = TagBlockReader.ReadTagBlock(reader, 1, address, layout, metaArea);
BoundingBoxes = (from entry in entries
select BoundingBox.Deserialize(entry)).ToArray();
}
private void LoadPermutations(StructureValueCollection values, IReader reader, FileSegmentGroup metaArea,
EngineDescription buildInfo)
{
var count = (int)values.GetInteger("number of permutations");
uint address = values.GetInteger("permutation table address");
StructureLayout layout = buildInfo.Layouts.GetLayout("model permutation");
StructureValueCollection[] entries = ReflexiveReader.ReadReflexive(reader, count, address, layout, metaArea);
Permutations = (from entry in entries
select new ThirdGenModelPermutation(entry)).ToArray();
}
public SecondGenTag(StructureValueCollection values, FileSegmentGroup metaArea, Dictionary <int, ITagGroup> groupsById)
{
Load(values, metaArea, groupsById);
}
private void LoadSoundPlaybacks(StructureValueCollection values, IReader reader, FileSegmentGroup metaArea, EngineDescription buildInfo)
{
var count = (int)values.GetInteger("number of playbacks");
var address = values.GetInteger("playback table address");
var layout = buildInfo.Layouts.GetLayout("sound playbacks");
var entries = ReflexiveReader.ReadReflexive(reader, count, address, layout, metaArea);
SoundPlaybacks = (from entry in entries
select new ThirdGenSoundPlayback(entry, SoundNames)).ToArray <ISoundPlayback>();
}
/*
* public FourthGenTag(StructureValueCollection values, ushort index, FileSegmentGroup metaArea,
* IList<ITagClass> classList)
* {
* Load(values, index, metaArea, classList);
* }
*/
public FourthGenTag(StructureValueCollection values, ushort index, FileSegmentGroup header, FileSegmentGroup metaArea, IList <ITagClass> classList)
{
Load(values, index, header, metaArea, classList);
}
/*
* private void LoadInteropData(StructureValueCollection map_values, StructureValueCollection tag_values)
* {
* // TODO: fix this shit for the h3beta
* //SectionOffsetMasks = headerValues.GetArray("offset masks").Select(v => v.GetInteger("mask")).ToArray();
* //Sections = headerValues.GetArray("sections").Select(v => new FourthGenInteropSection(v)).ToArray();
*
* //DebugPointerConverter = MakePointerConverter(FourthGenInteropSectionType.Debug);
* //ResourcePointerConverter = MakePointerConverter(FourthGenInteropSectionType.Resource);
* //TagBufferPointerConverter = MakePointerConverter(FourthGenInteropSectionType.Tag);
* //LocalePointerConverter = MakePointerConverter(FourthGenInteropSectionType.Localization);
* }
*/
/*
* private BasedPointerConverter MakePointerConverter(uint tags_data_size)
* {
*
* if (Sections[(int) section].Size == 0)
* return null;
*
* uint baseAddress = Sections[(int) section].VirtualAddress;
* uint mask = SectionOffsetMasks[(int) section];
* return new BasedPointerConverter(baseAddress, (int) (baseAddress + mask));
*
* return new BasedPointerConverter(0, 0);
* }
*/
/*
* private FileSegment CalculateRawTableSegment(FileSegmenter segmenter)
* {
* if (ResourcePointerConverter != null)
* {
* int rawTableOffset = ResourcePointerConverter.PointerToOffset(ResourcePointerConverter.BasePointer);
* var rawTableSize = (int) Sections[(int) FourthGenInteropSectionType.Resource].Size;
* return segmenter.WrapSegment(rawTableOffset, rawTableSize, 0x1000, SegmentResizeOrigin.End);
* }
* return null;
* }
*/
/*
* // TODO: Replace this function with the ability to parse the tags.dat file for this information.
* private FileSegment CalculateTagDataSegment(StructureValueCollection values, FileSegmenter segmenter)
* {
* int tagDataOffset = (int)values.GetInteger("tag buffer offset");
*
*
*
* if (TagBufferPointerConverter != null)
* {
* int tagDataOffset = TagBufferPointerConverter.PointerToOffset(TagBufferPointerConverter.BasePointer);
* var tagDataSize = (int) values.GetInteger("virtual size");
* return segmenter.WrapSegment(tagDataOffset, tagDataSize, 0x10000, SegmentResizeOrigin.Beginning);
* }
* return null;
* }
*/
private void CalculateStringGroup(StructureValueCollection values, FileSegmenter segmenter)
{
if (DebugPointerConverter == null)
{
return;
}
StringArea = new FileSegmentGroup(DebugPointerConverter);
// StringIDs
StringIDCount = (int)values.GetInteger("string table count");
if (StringIDCount > 0)
{
int sidIndexTableOff = DebugPointerConverter.PointerToOffset(values.GetInteger("string index table offset"));
int sidDataOff = DebugPointerConverter.PointerToOffset(values.GetInteger("string table offset"));
var sidTableSize = (int)values.GetInteger("string table size");
StringIDIndexTable = segmenter.WrapSegment(sidIndexTableOff, StringIDCount * 4, 4, SegmentResizeOrigin.End);
StringIDData = segmenter.WrapSegment(sidDataOff, sidTableSize, 1, SegmentResizeOrigin.End);
StringIDIndexTableLocation = StringArea.AddSegment(StringIDIndexTable);
StringIDDataLocation = StringArea.AddSegment(StringIDData);
// idk what this is, but H3Beta has it
if (values.HasInteger("string block offset"))
{
int sidBlockOff = DebugPointerConverter.PointerToOffset(values.GetInteger("string block offset"));
StringBlock = segmenter.WrapSegment(sidBlockOff, StringIDCount * 0x80, 0x80, SegmentResizeOrigin.End);
StringBlockLocation = StringArea.AddSegment(StringBlock);
}
}
/*
* // Tag names
* FileNameCount = (int) values.GetInteger("file table count");
* if (FileNameCount > 0)
* {
* int nameIndexTableOff = DebugPointerConverter.PointerToOffset(values.GetInteger("file index table offset"));
* int nameDataOff = DebugPointerConverter.PointerToOffset(values.GetInteger("file table offset"));
*
* var fileTableSize = (int) values.GetInteger("file table size");
* FileNameIndexTable = segmenter.WrapSegment(nameIndexTableOff, FileNameCount*4, 4, SegmentResizeOrigin.End);
* FileNameData = segmenter.WrapSegment(nameDataOff, fileTableSize, 1, SegmentResizeOrigin.End);
*
* FileNameIndexTableLocation = StringArea.AddSegment(FileNameIndexTable);
* FileNameDataLocation = StringArea.AddSegment(FileNameData);
* }
*/
/*
* // Some H4-only unknown table
* if (values.HasInteger("unknown table count") && values.HasInteger("unknown table offset"))
* {
* UnknownCount = (int) values.GetInteger("unknown table count");
* if (UnknownCount > 0)
* {
* int unknownOff = DebugPointerConverter.PointerToOffset(values.GetInteger("unknown table offset"));
* UnknownTable = segmenter.WrapSegment(unknownOff, UnknownCount*0x10, 0x10, SegmentResizeOrigin.End);
* UnknownTableLocation = StringArea.AddSegment(UnknownTable);
* }
* }
*/
}
public ThirdGenSimulationDefinitionTable(ITag scenario, TagTable tags, IReader reader, FileSegmentGroup metaArea, MetaAllocator allocator, EngineDescription buildInfo, IPointerExpander expander)
{
_scenario = scenario;
_tags = tags;
_metaArea = metaArea;
_allocator = allocator;
_buildInfo = buildInfo;
_expander = expander;
Load(reader);
}
