private void Load(StructureValueCollection values, FileSegmenter segmenter, FileSegmentGroup localeArea) { StringCount = (int)values.GetInteger("string count"); if (StringCount > 0) { // Index table offset, segment, and pointer int localeIndexTableOffset = localeArea.PointerToOffset((uint)values.GetInteger("locale index table offset")); LocaleIndexTable = segmenter.WrapSegment(localeIndexTableOffset, StringCount * 8, 8, SegmentResizeOrigin.End); LocaleIndexTableLocation = localeArea.AddSegment(LocaleIndexTable); // Data offset, segment, and pointer int localeDataOffset = localeArea.PointerToOffset((uint)values.GetInteger("locale data index offset")); var localeDataSize = (int)values.GetInteger("locale table size"); LocaleData = segmenter.WrapSegment(localeDataOffset, localeDataSize, _sizeAlign, SegmentResizeOrigin.End); LocaleDataLocation = localeArea.AddSegment(LocaleData); // Load hashes if they exist if (values.HasRaw("index table hash")) { IndexTableHash = values.GetRaw("index table hash"); } if (values.HasRaw("string data hash")) { StringDataHash = values.GetRaw("string data hash"); } } }
public void NotifiesOfSegmentWhenFileIsCreated() { //need to make this test var file = Path.GetTempFileName(); var info = new FileInfo(file); var refresher = new Subject <Unit>(); var segmenter = new FileSegmenter(info.WatchFile(refresher), 1000); FileSegmentCollection result = null; using (var indexer = segmenter.Segments.Subscribe(segment => result = segment)) { result.Should().NotBeNull(); File.AppendAllLines(file, Enumerable.Range(1, 10000).Select(i => $"This is line number {i.ToString("00000000")}").ToArray()); refresher.Once(); result.Should().NotBeNull(); result.Count.Should().BeGreaterOrEqualTo(2); result.Segments.Select(fs => fs.Type).Should().Contain(FileSegmentType.Head); result.Segments.Select(fs => fs.Type).Should().Contain(FileSegmentType.Tail); result.FileLength.Should().Be(info.Length); File.AppendAllLines(file, Enumerable.Range(101, 10).Select(i => $"{i}")); refresher.Once(); info.Refresh(); result.FileLength.Should().Be(info.Length); File.Delete(file); } File.Delete(file); }
public void MoreFileSegmentation() { TestFileCollection testFileCollection = new TestFileCollection(); for (int i = 0; i < 10; i++) { testFileCollection.Add(new TestFile()); testFileCollection[i].Append( Enumerable.Range(1, 1000).Select(j => $"{i}. file and this is line number {j.ToString("00000000")}").ToArray()); } var refresher = new Subject <Unit>(); var segmenter = new FileSegmenter(testFileCollection.Select(t => t.Info.WatchFile(refresher)).Merge(), 1000); FileSegmentCollection result = null; using (var indexer = segmenter.Segments.Subscribe(segment => result = segment)) { result.Should().NotBeNull(); var current = new FileSegmentCollection(result); int depthOfLink = 0; while (current != null) { depthOfLink++; current = current.Link; } depthOfLink.Should().Be(10); result.Segments.Select(fs => fs.Type).Should().Contain(FileSegmentType.Head); result.Segments.Select(fs => fs.Type).Should().Contain(FileSegmentType.Tail); testFileCollection.ForEach(t => t.Delete()); } testFileCollection.ForEach(t => t.Delete()); }
private static CompressionState AnalyzeSecondGen(IReader reader, EngineDescription engineInfo) { // H2 header is uncompressed, so the cache file needs to be loaded enough to check if the tag table is readable var segmenter = new FileSegmenter(engineInfo.SegmentAlignment); reader.SeekTo(0); StructureValueCollection headerValues = StructureReader.ReadStructure(reader, engineInfo.Layouts.GetLayout("header")); var metaOffset = (int)headerValues.GetInteger("meta offset"); var metaSize = (int)headerValues.GetInteger("meta size"); uint metaOffsetMask = (uint)headerValues.GetInteger("meta offset mask"); var metaSegment = new FileSegment( segmenter.DefineSegment(metaOffset, metaSize, 0x200, SegmentResizeOrigin.Beginning), segmenter); var MetaArea = new FileSegmentGroup(new MetaOffsetConverter(metaSegment, metaOffsetMask)); MetaArea.AddSegment(metaSegment); if (MetaArea.Offset >= reader.Length) { return(CompressionState.Compressed); } reader.SeekTo(MetaArea.Offset); StructureValueCollection tagTableValues = StructureReader.ReadStructure(reader, engineInfo.Layouts.GetLayout("meta header")); if ((uint)tagTableValues.GetInteger("magic") != CharConstant.FromString("tags")) { return(CompressionState.Compressed); } return(CompressionState.Decompressed); }
private void Load(StructureValueCollection values, FileSegmenter segmenter) { segmenter.DefineSegment(0, HeaderSize, 1, SegmentResizeOrigin.Beginning); // Define a segment for the header _eofSegment = segmenter.WrapEOF((int)values.GetInteger("file size")); Type = (CacheFileType)values.GetInteger("type"); LoadInteropData(values); RawTable = CalculateRawTableSegment(segmenter); InternalName = values.GetString("internal name"); ScenarioName = values.GetString("scenario name"); XDKVersion = (int)values.GetInteger("xdk version"); FileSegment metaSegment = CalculateTagDataSegment(values, segmenter); if (metaSegment != null) { ulong virtualBase = values.GetInteger("virtual base address"); MetaArea = new FileSegmentGroup(new MetaAddressConverter(metaSegment, (long)virtualBase)); MetaArea.AddSegment(metaSegment); IndexHeaderLocation = SegmentPointer.FromPointer((long)values.GetInteger("index header address"), MetaArea); Partitions = LoadPartitions(values.GetArray("partitions")); } else { Partitions = new Partition[0]; } CalculateStringGroup(values, segmenter); Checksum = (uint)values.GetInteger("checksum"); }
public SecondGenCacheFile(IReader reader, EngineDescription buildInfo, string buildString) { _buildInfo = buildInfo; _segmenter = new FileSegmenter(buildInfo.SegmentAlignment); Allocator = new MetaAllocator(this, 0x10000); Load(reader, buildInfo, buildString); }
public FourthGenCacheFile(IReader map_reader, IReader tag_reader, IReader string_reader, IReader tagnames_reader, EngineDescription buildInfo, string buildString) { _buildInfo = buildInfo; _segmenter = new FileSegmenter(buildInfo.SegmentAlignment); Allocator = new MetaAllocator(this, 0x10000); Load(map_reader, tag_reader, string_reader, tagnames_reader, buildString); }
public SecondGenHeader(StructureValueCollection values, EngineDescription info, string buildString, FileSegmenter segmenter) { BuildString = buildString; HeaderSize = info.HeaderSize; Load(values, segmenter); }
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 ThirdGenHeader(StructureValueCollection values, EngineDescription info, string buildString, FileSegmenter segmenter, IPointerExpander expander) { BuildString = buildString; HeaderSize = info.HeaderSize; _expander = expander; Load(values, segmenter); }
public FourthGenHeader(StructureValueCollection map_values, StructureValueCollection tag_values, StructureValueCollection string_values, EngineDescription info, string buildString, FileSegmenter segmenter) { EngineInfo = info; BuildString = buildString; HeaderSize = info.HeaderSize; Load(map_values, tag_values, string_values, segmenter); }
public ThirdGenCacheFile(IReader reader, EngineDescription buildInfo, string buildString) { _endianness = reader.Endianness; _buildInfo = buildInfo; _segmenter = new FileSegmenter(buildInfo.SegmentAlignment); _expander = new ThirdGenPointerExpander((uint)buildInfo.ExpandMagic); Allocator = new MetaAllocator(this, 0x10000); Load(reader, buildString); }
private FileSegment CalculateRawTableSegment(FileSegmenter segmenter) { if (ResourcePointerConverter != null) { int rawTableOffset = ResourcePointerConverter.PointerToOffset(ResourcePointerConverter.BasePointer); var rawTableSize = (int)Sections[(int)ThirdGenInteropSectionType.Resource].Size; return(segmenter.WrapSegment(rawTableOffset, rawTableSize, cacheSegmentAlignment, SegmentResizeOrigin.End)); } return(null); }
private FileSegment CalculateTagDataSegment(StructureValueCollection values, FileSegmenter segmenter) { 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); }
public SecondGenCacheFile(IReader reader, EngineDescription buildInfo, string filePath) { FilePath = filePath; _endianness = reader.Endianness; _buildInfo = buildInfo; _segmenter = new FileSegmenter(buildInfo.SegmentAlignment); _expander = new DummyPointerExpander(); Allocator = new MetaAllocator(this, 0x1000); Load(reader); }
public FirstGenCacheFile(IReader reader, EngineDescription buildInfo, string buildString) { _endianness = reader.Endianness; _buildInfo = buildInfo; _segmenter = new FileSegmenter(buildInfo.SegmentAlignment); _expander = new FirstGenPointerExpander(); // TODO (Dragon): not sure if this is right for first gen Allocator = new MetaAllocator(this, 0x10000); Load(reader, buildInfo, buildString); }
private void Load(StructureValueCollection values, FileSegmenter segmenter) { _eofSegment = segmenter.WrapEOF((int)values.GetInteger("file size")); var metaOffset = (int)values.GetInteger("meta offset"); int metaSize; // TODO (Dragon): hack for h2 alpha if (BuildString == "02.01.07.4998") { metaSize = (int)values.GetInteger("tag data offset") + (int)values.GetInteger("tag data size"); // hack to rewrite the "meta size" value even though its not actually the meta size //_saved_meta_size_hack = (uint)values.GetInteger("meta size"); } else { metaSize = (int)values.GetInteger("meta size"); } var metaSegment = new FileSegment( segmenter.DefineSegment(metaOffset, metaSize, 0x4, SegmentResizeOrigin.Beginning), segmenter); // we hacked in a meta header size into the values earlier in the cache load uint 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)); 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); // dummy stringids StringIDCount = 0; StringIDData = _eofSegment; StringIDIndexTable = _eofSegment; }
/* * private void AdjustPartitions() * { * if (MetaArea == null) * return; * * // Find the first partition with a non-null address and change it to the meta area's base address * Partition partition = Partitions.First(p => p.BasePointer != null); * if (partition != null) * partition.BasePointer = SegmentPointer.FromPointer(MetaArea.BasePointer, MetaArea); * * // Recalculate the size of each partition * int partitionEnd = MetaArea.Offset + MetaArea.Size; * for (int i = Partitions.Length - 1; i >= 0; i--) * { * if (Partitions[i].BasePointer == null) * continue; * * int offset = Partitions[i].BasePointer.AsOffset(); * Partitions[i].Size = (uint) (partitionEnd - offset); * partitionEnd = offset; * } * } */ /* * private StructureValueCollection[] SerializePartitions() * { * if (Partitions == null) * return new StructureValueCollection[0]; * * var results = new StructureValueCollection[Partitions.Length]; * for (int i = 0; i < Partitions.Length; i++) * { * var values = new StructureValueCollection(); * values.SetInteger("load address", Partitions[i].BasePointer != null ? Partitions[i].BasePointer.AsPointer() : 0); * values.SetInteger("size", Partitions[i].Size); * results[i] = values; * } * return results; * } */ /// <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) * { * * FourthGenInteropSection debugSection = Sections[(int) FourthGenInteropSectionType.Debug]; * FourthGenInteropSection rsrcSection = Sections[(int) FourthGenInteropSectionType.Resource]; * FourthGenInteropSection tagSection = Sections[(int) FourthGenInteropSectionType.Tag]; * FourthGenInteropSection localeSection = Sections[(int) FourthGenInteropSectionType.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 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) FourthGenInteropSectionType.Debug] != 0) * debugSection.VirtualAddress -= Partitions[0].Size; * * // Recompute offset masks * SectionOffsetMasks[(int) FourthGenInteropSectionType.Debug] = (debugSection.Size > 0) * ? (uint) (StringArea.Offset - debugSection.VirtualAddress) * : 0; * SectionOffsetMasks[(int) FourthGenInteropSectionType.Resource] = (rsrcSection.Size > 0) * ? (uint) (RawTable.Offset - rsrcSection.VirtualAddress) * : 0; * SectionOffsetMasks[(int) FourthGenInteropSectionType.Tag] = (tagSection.Size > 0) * ? (uint) (MetaArea.Offset - tagSection.VirtualAddress) * : 0; * SectionOffsetMasks[(int) FourthGenInteropSectionType.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; * } */ private void Load(StructureValueCollection map_values, StructureValueCollection tag_values, StructureValueCollection string_values, FileSegmenter map_segmenter) { map_segmenter.DefineSegment(0, HeaderSize, 1, SegmentResizeOrigin.Beginning); // Define a segment for the header _eofSegment = map_segmenter.WrapEOF((int)map_values.GetInteger("file size")); //LoadInteropData(map_values, tag_values); //RawTable = CalculateRawTableSegment(segmenter); Type = (CacheFileType)map_values.GetInteger("type"); InternalName = map_values.GetString("internal name"); ScenarioPath = map_values.GetString("scenario path"); uint index_header_address = map_values.GetInteger("index header address"); // File Segment FileSegmenter tags_segmenter = new FileSegmenter(); tags_segmenter.DefineSegment(0, (int)EngineInfo.TagsDataSize, 0x1, SegmentResizeOrigin.Beginning); // Define a segment for the header FileSegment metaSegment = new FileSegment(0, tags_segmenter); //FileSegment metaSegment = CalculateTagDataSegment(tag_values, segmenter); MetaArea = new FileSegmentGroup(new MetaAddressConverter(metaSegment, index_header_address)); MetaArea.AddSegment(metaSegment); IndexHeaderLocation = SegmentPointer.FromPointer(index_header_address, MetaArea); //XDKVersion = (int) values.GetInteger("xdk version"); /* * FileSegment metaSegment = CalculateTagDataSegment(values, segmenter); * if (metaSegment != null) * { * uint virtualBase = values.GetInteger("virtual base address"); * MetaArea = new FileSegmentGroup(new MetaAddressConverter(metaSegment, virtualBase)); * MetaArea.AddSegment(metaSegment); * * IndexHeaderLocation = SegmentPointer.FromPointer(values.GetInteger("index header address"), MetaArea); * Partitions = LoadPartitions(values.GetArray("partitions")); * } * else * { * Partitions = new Partition[0]; * } */ CalculateStringGroup(string_values, map_segmenter); }
/// <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); }
public ThirdGenLanguage(GameLanguage language, StructureValueCollection values, FileSegmenter segmenter, FileSegmentGroup localeArea, EngineDescription buildInfo) { Language = language; _pointerLayout = buildInfo.Layouts.GetLayout("locale index table element"); _encryptionKey = buildInfo.LocaleKey; _sizeAlign = (_encryptionKey != null) ? AES.BlockSize : 1; Load(values, segmenter, localeArea); }
public ThirdGenHeader(StructureValueCollection values, EngineDescription info, FileSegmenter segmenter, IPointerExpander expander) { BuildString = info.BuildVersion; HeaderSize = info.HeaderSize; cacheSegmentAlignment = info.SegmentAlignment; _expander = expander; Load(values, segmenter); }
private List <ThirdGenLanguage> LoadLanguages(StructureValueCollection values, FileSegmenter segmenter, EngineDescription buildInfo) { StructureValueCollection[] languageSet = values.GetArray("languages"); IEnumerable <ThirdGenLanguage> result = languageSet.Select((l, i) => new ThirdGenLanguage((GameLanguage)i, l, segmenter, LocaleArea, buildInfo)); return(result.ToList()); }
private void Load(StructureValueCollection values, FileSegmenter segmenter) { _eofSegment = segmenter.WrapEOF((int)values.GetInteger("file size")); var metaOffset = (int)values.GetInteger("meta offset"); var metaSize = (int)values.GetInteger("meta size"); uint metaOffsetMask = values.GetInteger("meta offset mask"); var metaSegment = new FileSegment( segmenter.DefineSegment(metaOffset, metaSize, 0x200, SegmentResizeOrigin.Beginning), segmenter); 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)); 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"); RawTable = segmenter.WrapSegment(rawTableOffset, rawTableSize, 1, SegmentResizeOrigin.End); Checksum = 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); }
private List <FourthGenLanguage> LoadLanguages(StructureValueCollection values, FileSegmenter segmenter, EngineDescription buildInfo) { StructureValueCollection[] languageSet = values.GetArray("languages"); List <FourthGenLanguage> list = new List <FourthGenLanguage>(); for (int i = 0; i < languageSet.Length; i++) { list.Add(new FourthGenLanguage((GameLanguage)i, languageSet[i], segmenter, LocaleArea, buildInfo)); } //IEnumerable<FourthGenLanguage> result = languageSet.Select((l, i) => new FourthGenLanguage((GameLanguage) i, l, segmenter, LocaleArea, buildInfo)); //return result.ToList(); return(list); }
public FirstGenHeader(StructureValueCollection values, EngineDescription info, FileSegmenter segmenter) { BuildString = info.BuildVersion; HeaderSize = info.HeaderSize; Load(values, segmenter); }
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 FourthGenLanguageGlobals(StructureValueCollection values, FileSegmenter segmenter, IPointerConverter localePointerConverter, EngineDescription buildInfo) { LocaleArea = new FileSegmentGroup(localePointerConverter); Languages = LoadLanguages(values, segmenter, buildInfo); }
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); //xbox haxx, we can assume thru the existance of the code-set xbox mask uint metaOffsetMask; FileSegment metaSegment = null; if (values.HasInteger("xbox meta offset mask")) { // 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"); metaOffsetMask = (uint)values.GetInteger("xbox meta offset mask"); metaSegment = new FileSegment( segmenter.DefineSegment(metaOffset + tagTableSize, tagDataSize, 0x4, SegmentResizeOrigin.End), segmenter); } else { metaOffsetMask = (uint)values.GetInteger("meta offset mask"); metaSegment = new FileSegment( segmenter.DefineSegment(metaOffset + tagTableSize, tagDataSize, 0x1000, SegmentResizeOrigin.End), segmenter); } MetaArea = new FileSegmentGroup(new MetaOffsetConverter(headSegment, 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); if (values.HasInteger("file table count")) { 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(); 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); if (FileNameIndexTable != null) { StringArea.AddSegment(FileNameIndexTable); StringArea.AddSegment(FileNameData); FileNameIndexTableLocation = SegmentPointer.FromOffset(FileNameIndexTable.Offset, StringArea); FileNameDataLocation = SegmentPointer.FromOffset(FileNameData.Offset, StringArea); } int rawTableOffset; int rawTableSize; if (values.HasInteger("raw table offset")) { rawTableOffset = (int)values.GetInteger("raw table offset"); 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); }
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 SecondGenLanguage(GameLanguage language, StructureValueCollection values, FileSegmenter segmenter, FileSegmentGroup localeArea, EngineDescription buildInfo) { Language = language; _pointerLayout = buildInfo.Layouts.GetLayout("locale index table element"); _hashes = buildInfo.UsesStringHashes; _sizeAlign = 0x1; Load(values, segmenter, localeArea); }