/// <summary> /// Gets the DBRecord for a particular ID. /// </summary> /// <param name="recordId">string ID of the record will be normalized internally</param> /// <returns>DBRecord corresponding to the string ID.</returns> public DBRecordCollection GetItem(string recordId) { if (string.IsNullOrEmpty(recordId)) { return(null); } DBRecordCollection databaseRecord; recordId = TQData.NormalizeRecordPath(recordId); if (cache.ContainsKey(recordId)) { databaseRecord = this.cache[recordId]; } else { RecordInfo rawRecord; if (this.recordInfo.ContainsKey(recordId)) { rawRecord = this.recordInfo[recordId]; } else { // record not found return(null); } databaseRecord = rawRecord.Decompress(this); this.cache.Add(recordId, databaseRecord); } return(databaseRecord); }
/// <summary> /// Gets a DBRecord for the specified item ID string. /// </summary> /// <remarks> /// Changed by VillageIdiot /// Changed search order so that IT records have precedence of TQ records. /// Add Custom Map database. Custom Map records have precedence over IT records. /// </remarks> /// <param name="itemId">Item Id which we are looking up</param> /// <returns>Returns the DBRecord for the item Id</returns> public DBRecordCollection GetRecordFromFile(string itemId) { itemId = TQData.NormalizeRecordPath(itemId); if (this.ArzFileMod != null) { DBRecordCollection recordMod = this.ArzFileMod.GetItem(itemId); if (recordMod != null) { // Custom Map records have highest precedence. return(recordMod); } } if (this.ArzFileIT != null) { // see if it's in IT ARZ file DBRecordCollection recordIT = this.ArzFileIT.GetItem(itemId); if (recordIT != null) { // IT file takes precedence over TQ. return(recordIT); } } return(ArzFile.GetItem(itemId)); }
/// <summary> /// Gets the Infor for a specific item id. /// </summary> /// <param name="itemId">Item ID which we are looking up. Will be normalized internally.</param> /// <returns>Returns Infor for item ID and NULL if not found.</returns> public Info GetInfo(string itemId) { Info result = null; if (string.IsNullOrEmpty(itemId)) { return(result); } itemId = TQData.NormalizeRecordPath(itemId); Info info; if (infoDB.ContainsKey(itemId)) { info = this.infoDB[itemId]; } else { DBRecordCollection record = null; // Add support for searching a custom map database if (this.ArzFileMod != null) { record = this.ArzFileMod.GetItem(itemId); } // Try the expansion pack database first. if (record == null && this.ArzFileIT != null) { record = this.ArzFileIT.GetItem(itemId); } // Try looking in TQ database now if (record == null || this.ArzFileIT == null) { record = this.ArzFile.GetItem(itemId); } if (record == null) { return(null); } info = new Info(record); this.infoDB.Add(itemId, info); } return(info); }
/// <summary> /// Gets a database record without adding it to the cache. /// </summary> /// <remarks> /// The Item property caches the DBRecords, which is great when you are only using a few 100 (1000?) records and are requesting /// them many times. Not great if you are looping through all the records as it eats alot of memory. This method will create /// the record on the fly if it is not in the cache so when you are done with it, it can be reclaimed by the garbage collector. /// Great for when you want to loop through all the records for some reason. It will take longer, but use less memory. /// </remarks> /// <param name="recordId">String ID of the record. Will be normalized internally.</param> /// <returns>Decompressed RecordInfo record</returns> public DBRecordCollection GetRecordNotCached(string recordId) { recordId = TQData.NormalizeRecordPath(recordId); try { // If it is already in the cache no need not to use it return(this.cache[recordId]); } catch (KeyNotFoundException ex) { Log.Debug("record not found first attempt", ex); try { return(this.recordInfo[recordId].Decompress(this)); } catch (KeyNotFoundException exx) { Log.Debug("record not found second attempt", exx); return(null); } } }
/// <summary> /// Reads the entire record table into memory from a stream. /// </summary> /// <param name="pos">position within the file.</param> /// <param name="numEntries">number of entries in the file.</param> /// <param name="reader">input BinaryReader</param> /// <param name="outStream">output StreamWriter.</param> private void ReadRecordTable(int pos, int numEntries, BinaryReader reader, StreamWriter outStream) { this.recordInfo = new Dictionary <string, RecordInfo>((int)Math.Round(numEntries * 1.2)); reader.BaseStream.Seek(pos, SeekOrigin.Begin); if (outStream != null) { outStream.WriteLine("RecordTable located at 0x{0:X}", pos); } for (int i = 0; i < numEntries; ++i) { RecordInfo recordInfo = new RecordInfo(); recordInfo.Decode(reader, 24, this); // 24 is the offset of where all record data begins this.recordInfo.Add(TQData.NormalizeRecordPath(recordInfo.ID), recordInfo); // output this record if (outStream != null) { outStream.WriteLine("{0},{1},{2}", i, recordInfo.ID, recordInfo.RecordType); } } }
/// <summary> /// Gets a resource from the database using the resource Id. /// Modified by VillageIdiot to support loading resources from a custom map folder. /// </summary> /// <param name="resourceId">Resource which we are fetching</param> /// <returns>Retruns a byte array of the resource.</returns> public byte[] LoadResource(string resourceId) { if (TQDebug.DatabaseDebugLevel > 0) { Log.DebugFormat(CultureInfo.InvariantCulture, "Database.LoadResource({0})", resourceId); } resourceId = TQData.NormalizeRecordPath(resourceId); if (TQDebug.DatabaseDebugLevel > 1) { Log.DebugFormat(CultureInfo.InvariantCulture, " Normalized({0})", resourceId); } // First we need to figure out the correct file to // open, by grabbing it off the front of the resourceID int backslashLocation = resourceId.IndexOf('\\'); if (backslashLocation <= 0) { // not a proper resourceID. return(null); } string arcFileBase = resourceId.Substring(0, backslashLocation); if (TQDebug.DatabaseDebugLevel > 1) { Log.DebugFormat(CultureInfo.InvariantCulture, "arcFileBase = {0}", arcFileBase); } string rootFolder; string arcFile; byte[] arcFileData = null; // Added by VillageIdiot // Check the mod folder for the image resource. if (TQData.IsCustom) { if (TQDebug.DatabaseDebugLevel > 1) { Log.Debug("Checking Custom Resources."); } rootFolder = Path.Combine(TQData.MapName, "resources"); arcFile = Path.Combine(rootFolder, Path.ChangeExtension(arcFileBase, ".arc")); arcFileData = this.ReadARCFile(arcFile, resourceId); } // We either didn't load the resource or didn't find what we were looking for so check the normal game resources. if (arcFileData == null) { // See if this guy is from Immortal Throne expansion pack. if (TQDebug.DatabaseDebugLevel > 1) { Log.Debug("Checking IT Resources."); } rootFolder = TQData.ImmortalThronePath; bool xpack = false; if (arcFileBase.ToUpperInvariant().Equals("XPACK")) { // Comes from Immortal Throne xpack = true; rootFolder = Path.Combine(Path.Combine(rootFolder, "Resources"), "XPack"); } else if (arcFileBase.ToUpperInvariant().Equals("XPACK2")) { // Comes from Ragnarok xpack = true; rootFolder = Path.Combine(Path.Combine(rootFolder, "Resources"), "XPack2"); } else if (arcFileBase.ToUpperInvariant().Equals("XPACK3")) { // Comes from Atlantis xpack = true; rootFolder = Path.Combine(Path.Combine(rootFolder, "Resources"), "XPack3"); } if (xpack == true) { // throw away that value and use the next field. int previousBackslash = backslashLocation; backslashLocation = resourceId.IndexOf('\\', backslashLocation + 1); if (backslashLocation <= 0) { return(null); // not a proper resourceID } arcFileBase = resourceId.Substring(previousBackslash + 1, backslashLocation - previousBackslash - 1); resourceId = resourceId.Substring(previousBackslash + 1); } else { // Changed by VillageIdiot to search the IT resources folder for updated resources // if IT is installed otherwise just the TQ folder. rootFolder = Path.Combine(rootFolder, "Resources"); } arcFile = Path.Combine(rootFolder, Path.ChangeExtension(arcFileBase, ".arc")); arcFileData = this.ReadARCFile(arcFile, resourceId); } // Added by VillageIdiot // Maybe the arc file is in the XPack folder even though the record does not state it. // Also could be that it says xpack in the record but the file is in the root. if (arcFileData == null) { rootFolder = Path.Combine(Path.Combine(TQData.ImmortalThronePath, "Resources"), "XPack"); arcFile = Path.Combine(rootFolder, Path.ChangeExtension(arcFileBase, ".arc")); arcFileData = this.ReadARCFile(arcFile, resourceId); } // Now, let's check if the item is in Ragnarok DLC if (arcFileData == null && TQData.IsRagnarokInstalled) { rootFolder = Path.Combine(Path.Combine(TQData.ImmortalThronePath, "Resources"), "XPack2"); arcFile = Path.Combine(rootFolder, Path.ChangeExtension(arcFileBase, ".arc")); arcFileData = this.ReadARCFile(arcFile, resourceId); } if (arcFileData == null && TQData.IsAtlantisInstalled) { rootFolder = Path.Combine(Path.Combine(TQData.ImmortalThronePath, "Resources"), "XPack3"); arcFile = Path.Combine(rootFolder, Path.ChangeExtension(arcFileBase, ".arc")); arcFileData = this.ReadARCFile(arcFile, resourceId); } if (arcFileData == null) { // We are either vanilla TQ or have not found our resource yet. // from the original TQ folder if (TQDebug.DatabaseDebugLevel > 1) { Log.Debug("Checking TQ Resources."); } rootFolder = TQData.TQPath; rootFolder = Path.Combine(rootFolder, "Resources"); arcFile = Path.Combine(rootFolder, Path.ChangeExtension(arcFileBase, ".arc")); arcFileData = this.ReadARCFile(arcFile, resourceId); } if (TQDebug.DatabaseDebugLevel > 0) { Log.Debug("Exiting Database.LoadResource()"); } return(arcFileData); }
/// <summary> /// Read the table of contents of the ARC file /// </summary> private void ReadARCToC() { // Format of an ARC file // 0x08 - 4 bytes = # of files // 0x0C - 4 bytes = # of parts // 0x18 - 4 bytes = offset to directory structure // // Format of directory structure // 4-byte int = offset in file where this part begins // 4-byte int = size of compressed part // 4-byte int = size of uncompressed part // these triplets repeat for each part in the arc file // After these triplets are a bunch of null-terminated strings // which are the sub filenames. // After the subfilenames comes the subfile data: // 4-byte int = 3 == indicates start of subfile item (maybe compressed flag??) // 1 == maybe uncompressed flag?? // 4-byte int = offset in file where first part of this subfile begins // 4-byte int = compressed size of this file // 4-byte int = uncompressed size of this file // 4-byte crap // 4-byte crap // 4-byte crap // 4-byte int = numParts this file uses // 4-byte int = part# of first part for this file (starting at 0). // 4-byte int = length of filename string // 4-byte int = offset in directory structure for filename this.fileHasBeenRead = true; if (TQDebug.ArcFileDebugLevel > 0) { Log.DebugFormat(CultureInfo.InvariantCulture, "ARCFile.ReadARCToC({0})", this.FileName); } try { using (FileStream arcFile = new FileStream(this.FileName, FileMode.Open, FileAccess.Read)) { using (BinaryReader reader = new BinaryReader(arcFile)) { if (TQDebug.ArcFileDebugLevel > 1) { Log.DebugFormat(CultureInfo.InvariantCulture, "File Length={0}", arcFile.Length); } // check the file header if (reader.ReadByte() != 0x41) { return; } if (reader.ReadByte() != 0x52) { return; } if (reader.ReadByte() != 0x43) { return; } if (arcFile.Length < 0x21) { return; } reader.BaseStream.Seek(0x08, SeekOrigin.Begin); int numEntries = reader.ReadInt32(); int numParts = reader.ReadInt32(); if (TQDebug.ArcFileDebugLevel > 1) { Log.DebugFormat(CultureInfo.InvariantCulture, "numEntries={0}, numParts={1}", numEntries, numParts); } ARCPartEntry[] parts = new ARCPartEntry[numParts]; ARCDirEntry[] records = new ARCDirEntry[numEntries]; if (TQDebug.ArcFileDebugLevel > 2) { Log.Debug("Seeking to tocOffset location"); } reader.BaseStream.Seek(0x18, SeekOrigin.Begin); int tocOffset = reader.ReadInt32(); if (TQDebug.ArcFileDebugLevel > 1) { Log.DebugFormat(CultureInfo.InvariantCulture, "tocOffset = {0}", tocOffset); } // Make sure all 3 entries exist for the toc entry. if (arcFile.Length < (tocOffset + 12)) { return; } // Read in all of the part data reader.BaseStream.Seek(tocOffset, SeekOrigin.Begin); int i; for (i = 0; i < numParts; ++i) { parts[i] = new ARCPartEntry(); parts[i].FileOffset = reader.ReadInt32(); parts[i].CompressedSize = reader.ReadInt32(); parts[i].RealSize = reader.ReadInt32(); if (TQDebug.ArcFileDebugLevel > 2) { Log.DebugFormat(CultureInfo.InvariantCulture, "parts[{0}]", i); Log.DebugFormat(CultureInfo.InvariantCulture , " fileOffset={0}, compressedSize={1}, realSize={2}" , parts[i].FileOffset , parts[i].CompressedSize , parts[i].RealSize ); } } // Now record this offset so we can come back and read in the filenames // after we have read in the file records int fileNamesOffset = (int)arcFile.Position; // Now seek to the location where the file record data is // This offset is from the end of the file. int fileRecordOffset = 44 * numEntries; if (TQDebug.ArcFileDebugLevel > 1) { Log.DebugFormat(CultureInfo.InvariantCulture , "fileNamesOffset = {0}. Seeking to {1} to read file record data." , fileNamesOffset , fileRecordOffset ); } arcFile.Seek(-1 * fileRecordOffset, SeekOrigin.End); for (i = 0; i < numEntries; ++i) { records[i] = new ARCDirEntry(); // storageType = 3 - compressed / 1- non compressed int storageType = reader.ReadInt32(); if (TQDebug.ArcFileDebugLevel > 2) { Log.DebugFormat(CultureInfo.InvariantCulture, "StorageType={0}", storageType); } // Added by VillageIdiot to support stored types records[i].StorageType = storageType; records[i].FileOffset = reader.ReadInt32(); records[i].CompressedSize = reader.ReadInt32(); records[i].RealSize = reader.ReadInt32(); int crap = reader.ReadInt32(); // crap if (TQDebug.ArcFileDebugLevel > 2) { Log.DebugFormat(CultureInfo.InvariantCulture, "Crap2={0}", crap); } crap = reader.ReadInt32(); // crap if (TQDebug.ArcFileDebugLevel > 2) { Log.DebugFormat(CultureInfo.InvariantCulture, "Crap3={0}", crap); } crap = reader.ReadInt32(); // crap if (TQDebug.ArcFileDebugLevel > 2) { Log.DebugFormat(CultureInfo.InvariantCulture, "Crap4={0}", crap); } int numberOfParts = reader.ReadInt32(); if (numberOfParts < 1) { records[i].Parts = null; if (TQDebug.ArcFileDebugLevel > 2) { Log.DebugFormat(CultureInfo.InvariantCulture, "File {0} is not compressed.", i); } } else { records[i].Parts = new ARCPartEntry[numberOfParts]; } int firstPart = reader.ReadInt32(); crap = reader.ReadInt32(); // filename length if (TQDebug.ArcFileDebugLevel > 2) { Log.DebugFormat(CultureInfo.InvariantCulture, "Filename Length={0}", crap); } crap = reader.ReadInt32(); // filename offset if (TQDebug.ArcFileDebugLevel > 2) { Log.DebugFormat(CultureInfo.InvariantCulture, "Filename Offset={0}", crap); Log.DebugFormat(CultureInfo.InvariantCulture, "record[{0}]", i); Log.DebugFormat( CultureInfo.InvariantCulture, " offset={0} compressedSize={1} realSize={2}", records[i].FileOffset, records[i].CompressedSize, records[i].RealSize); if (storageType != 1 && records[i].IsActive) { Log.DebugFormat( CultureInfo.InvariantCulture, " numParts={0} firstPart={1} lastPart={2}", records[i].Parts.Length, firstPart, firstPart + records[i].Parts.Length - 1); } else { Log.DebugFormat(CultureInfo.InvariantCulture, " INACTIVE firstPart={0}", firstPart); } } if (storageType != 1 && records[i].IsActive) { for (int ip = 0; ip < records[i].Parts.Length; ++ip) { records[i].Parts[ip] = parts[ip + firstPart]; } } } // Now read in the record names arcFile.Seek(fileNamesOffset, SeekOrigin.Begin); byte[] buffer = new byte[2048]; ASCIIEncoding ascii = new ASCIIEncoding(); for (i = 0; i < numEntries; ++i) { // only Active files have a filename entry if (records[i].IsActive) { // For each string, read bytes until I hit a 0x00 byte. if (TQDebug.ArcFileDebugLevel > 2) { Log.DebugFormat(CultureInfo.InvariantCulture, "Reading entry name {0:n0}", i); } int bufferSize = 0; while ((buffer[bufferSize++] = reader.ReadByte()) != 0x00) { if (buffer[bufferSize - 1] == 0x03) { // File is null? arcFile.Seek(-1, SeekOrigin.Current); // backup bufferSize--; buffer[bufferSize] = 0x00; if (TQDebug.ArcFileDebugLevel > 2) { Log.Debug("Null file - inactive?"); } break; } if (bufferSize >= buffer.Length) { Log.Debug("ARCFile.ReadARCToC() Error - Buffer size of 2048 has been exceeded."); if (TQDebug.ArcFileDebugLevel > 2) { var content = buffer.Select(b => string.Format(CultureInfo.InvariantCulture, "0x{0:X}", b)).ToArray(); Log.Debug($"Buffer contents:{Environment.NewLine}{string.Join(string.Empty, content)}{Environment.NewLine}{string.Empty}"); } } } if (TQDebug.ArcFileDebugLevel > 2) { Log.DebugFormat( CultureInfo.InvariantCulture, "Read {0:n0} bytes for name. Converting to string.", bufferSize); } string newfile; if (bufferSize >= 1) { // Now convert the buffer to a string char[] chars = new char[ascii.GetCharCount(buffer, 0, bufferSize - 1)]; ascii.GetChars(buffer, 0, bufferSize - 1, chars, 0); newfile = new string(chars); } else { newfile = string.Format(CultureInfo.InvariantCulture, "Null File {0}", i); } records[i].FileName = TQData.NormalizeRecordPath(newfile); if (TQDebug.ArcFileDebugLevel > 2) { Log.DebugFormat(CultureInfo.InvariantCulture, "Name {0:n0} = '{1}'", i, records[i].FileName); } } } // Now convert the array of records into a Dictionary. Dictionary <string, ARCDirEntry> dictionary = new Dictionary <string, ARCDirEntry>(numEntries); if (TQDebug.ArcFileDebugLevel > 1) { Log.Debug("Creating Dictionary"); } for (i = 0; i < numEntries; ++i) { if (records[i].IsActive) { dictionary.Add(records[i].FileName, records[i]); } } this.directoryEntries = dictionary; if (TQDebug.ArcFileDebugLevel > 0) { Log.Debug("Exiting ARCFile.ReadARCToC()"); } } } } catch (IOException exception) { Log.Error("ARCFile.ReadARCToC() - Error reading arcfile", exception); } }
/// <summary> /// Reads data from an ARC file and puts it into a Byte array (or NULL if not found) /// </summary> /// <param name="dataId">The string ID for the data which we are retieving.</param> /// <returns>Returns byte array of the data corresponding to the string ID.</returns> public byte[] GetData(string dataId) { if (TQDebug.ArcFileDebugLevel > 0) { Log.DebugFormat(CultureInfo.InvariantCulture, "ARCFile.GetData({0})", dataId); } if (!this.fileHasBeenRead) { this.ReadARCToC(); } if (this.directoryEntries == null) { if (TQDebug.ArcFileDebugLevel > 1) { Log.DebugFormat(CultureInfo.InvariantCulture, "Error - Could not read {0}", this.FileName); } // could not read the file return(null); } // First normalize the filename dataId = TQData.NormalizeRecordPath(dataId); if (TQDebug.ArcFileDebugLevel > 1) { Log.DebugFormat(CultureInfo.InvariantCulture, "Normalized dataID = {0}", dataId); } // Find our file in the toc. // First strip off the leading folder since it is just the ARC name int firstPathDelim = dataId.IndexOf('\\'); if (firstPathDelim != -1) { dataId = dataId.Substring(firstPathDelim + 1); } // Now see if this file is in the toc. ARCDirEntry directoryEntry; if (directoryEntries.ContainsKey(dataId)) { directoryEntry = this.directoryEntries[dataId]; } else { // record not found if (TQDebug.ArcFileDebugLevel > 1) { Log.DebugFormat(CultureInfo.InvariantCulture, "Error - {0} not found.", dataId); } return(null); } // Now open the ARC file and read in the record. using (FileStream arcFile = new FileStream(this.FileName, FileMode.Open, FileAccess.Read)) { // Allocate memory for the uncompressed data byte[] data = new byte[directoryEntry.RealSize]; // Now process each part of this record int startPosition = 0; // First see if the data was just stored without compression. if ((directoryEntry.StorageType == 1) && (directoryEntry.CompressedSize == directoryEntry.RealSize)) { if (TQDebug.ArcFileDebugLevel > 1) { Log.DebugFormat(CultureInfo.InvariantCulture , "Offset={0} Size={1}" , directoryEntry.FileOffset , directoryEntry.RealSize ); } arcFile.Seek(directoryEntry.FileOffset, SeekOrigin.Begin); arcFile.Read(data, 0, directoryEntry.RealSize); } else { // The data was compressed so we attempt to decompress it. foreach (ARCPartEntry partEntry in directoryEntry.Parts) { // seek to the part we want arcFile.Seek(partEntry.FileOffset, SeekOrigin.Begin); // Ignore the zlib compression method. arcFile.ReadByte(); // Ignore the zlib compression flags. arcFile.ReadByte(); // Create a deflate stream. using (DeflateStream deflate = new DeflateStream(arcFile, CompressionMode.Decompress, true)) { int bytesRead; int partLength = 0; while ((bytesRead = deflate.Read(data, startPosition, data.Length - startPosition)) > 0) { startPosition += bytesRead; partLength += bytesRead; // break out of the read loop if we have processed this part completely. if (partLength >= partEntry.RealSize) { break; } } } } } if (TQDebug.ArcFileDebugLevel > 0) { Log.Debug("Exiting ARCFile.GetData()"); } return(data); } }