/// <summary>
/// Parses the binary equipment block data
/// </summary>
/// <param name="offset">offset of the block within the player file.</param>
/// <param name="reader">BinaryReader instance</param>
private void ParseEquipmentBlock(int offset, BinaryReader reader)
{
try
{
this.equipmentBlockStart = offset;
reader.BaseStream.Seek(offset, SeekOrigin.Begin);
if (this.IsImmortalThrone)
{
TQData.ValidateNextString("equipmentCtrlIOStreamVersion", reader);
this.equipmentCtrlIOStreamVersion = reader.ReadInt32();
}
this.EquipmentSack = new SackCollection();
this.EquipmentSack.SackType = SackType.Equipment;
this.EquipmentSack.IsImmortalThrone = this.IsImmortalThrone;
this.EquipmentSack.Parse(reader);
this.equipmentBlockEnd = (int)reader.BaseStream.Position;
}
catch (ArgumentException)
{
throw;
}
}
/// <summary>
/// Decodes the ARZ file.
/// </summary>
/// <param name="inReader">input BinaryReader</param>
/// <param name="baseOffset">Offset in the file.</param>
/// <param name="arzFile">ArzFile instance which we are operating.</param>
public void Decode(BinaryReader inReader, int baseOffset, ArzFile arzFile)
{
// Record Entry Format
// 0x0000 int32 stringEntryID (dbr filename)
// 0x0004 int32 string length
// 0x0008 string (record type)
// 0x00?? int32 offset
// 0x00?? int32 length in bytes
// 0x00?? int32 timestamp?
// 0x00?? int32 timestamp?
this.idStringIndex = inReader.ReadInt32();
this.RecordType = TQData.ReadCString(inReader);
this.offset = inReader.ReadInt32() + baseOffset;
// Compressed size
// We throw it away and just advance the offset in the file.
inReader.ReadInt32();
// Crap1 - timestamp?
// We throw it away and just advance the offset in the file.
inReader.ReadInt32();
// Crap2 - timestamp?
// We throw it away and just advance the offset in the file.
inReader.ReadInt32();
// Get the ID string
this.ID = arzFile.Getstring(this.idStringIndex);
}
/// <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)
{
DBRecordCollection result = null;
if (string.IsNullOrEmpty(recordId))
{
return(result);
}
recordId = TQData.NormalizeRecordPath(recordId);
DBRecordCollection databaseRecord;
if (cache.ContainsKey(recordId))
{
databaseRecord = this.cache[recordId];
}
else
{
RecordInfo rawRecord;
if (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 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)
{
DBRecordCollection result = null;
if (string.IsNullOrEmpty(recordId))
{
return(result);
}
recordId = TQData.NormalizeRecordPath(recordId);
DBRecordCollection databaseRecord;
try
{
databaseRecord = this.cache[recordId];
}
catch (KeyNotFoundException)
{
RecordInfo rawRecord;
try
{
rawRecord = this.recordInfo[recordId];
}
catch (KeyNotFoundException)
{
// record not found
return(null);
}
databaseRecord = rawRecord.Decompress(this);
this.cache.Add(recordId, databaseRecord);
}
return(databaseRecord);
}
/// <summary>
/// Encodes the internal item data back into raw data
/// </summary>
/// <returns>raw data for the item data</returns>
private byte[] EncodeItemData()
{
int dataLength;
byte[] data;
// Encode the item data into a memory stream
using (MemoryStream writeStream = new MemoryStream(2048))
{
using (BinaryWriter writer = new BinaryWriter(writeStream))
{
// Write zero into the checksum value
writer.Write(Convert.ToInt32(0, CultureInfo.InvariantCulture));
TQData.WriteCString(writer, "begin_block");
writer.Write(this.beginBlockCrap);
TQData.WriteCString(writer, "stashVersion");
writer.Write(this.stashVersion);
TQData.WriteCString(writer, "fName");
// Changed to raw data to support extended characters
writer.Write(this.name.Length);
writer.Write(this.name);
TQData.WriteCString(writer, "sackWidth");
writer.Write(this.Width);
TQData.WriteCString(writer, "sackHeight");
writer.Write(this.Height);
// SackType should already be set at this point
this.sack.Encode(writer);
dataLength = (int)writeStream.Length;
}
// now just return the buffer we wrote to.
data = writeStream.GetBuffer();
}
// The problem is that data[] may be bigger than the amount of data in it.
// We need to resize the array
if (dataLength == data.Length)
{
return(data);
}
byte[] realData = new byte[dataLength];
Array.Copy(data, realData, dataLength);
return(realData);
}
/// <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)
{
DBRecordCollection result = null;
if (string.IsNullOrEmpty(recordId))
{
return(result);
}
recordId = TQData.NormalizeRecordPath(recordId);
if (!cache.ContainsKey(recordId))
{
return(OnCachedItemNotFound(recordId));
}
return(this.cache[recordId]);
}
/// <summary>
/// Encodes the live item data into raw binary format
/// </summary>
/// <returns>byte array holding the converted binary data</returns>
private byte[] EncodeItemData()
{
int dataLength;
byte[] data;
// Encode the item data into a memory stream
using (MemoryStream writeStream = new MemoryStream(2048))
{
using (BinaryWriter writer = new BinaryWriter(writeStream))
{
TQData.WriteCString(writer, "numberOfSacks");
writer.Write(this.numberOfSacks);
TQData.WriteCString(writer, "currentlyFocusedSackNumber");
writer.Write(this.currentlyFocusedSackNumber);
TQData.WriteCString(writer, "currentlySelectedSackNumber");
writer.Write(this.currentlySelectedSackNumber);
for (int i = 0; i < this.numberOfSacks; ++i)
{
// SackType should already be set at this point
this.sacks[i].Encode(writer);
}
dataLength = (int)writeStream.Length;
}
// now just return the buffer we wrote to.
data = writeStream.GetBuffer();
}
// The problem is that ans() may be bigger than the amount of data in it.
// We need to resize the array
if (dataLength == data.Length)
{
return(data);
}
byte[] realData = new byte[dataLength];
Array.Copy(data, realData, dataLength);
return(realData);
}
/// <summary>
/// Reads the whole string table into memory from a stream.
/// </summary>
/// <remarks>
/// string Table Format
/// first 4 bytes is the number of entries
/// then
/// one string followed by another...
/// </remarks>
/// <param name="pos">position within the file.</param>
/// <param name="reader">input BinaryReader</param>
/// <param name="outStream">output StreamWriter.</param>
private void ReadStringTable(int pos, BinaryReader reader, StreamWriter outStream)
{
reader.BaseStream.Seek(pos, SeekOrigin.Begin);
int numstrings = reader.ReadInt32();
this.strings = new string[numstrings];
if (outStream != null)
{
outStream.WriteLine("stringTable located at 0x{1:X} numstrings= {0:n0}", numstrings, pos);
}
for (int i = 0; i < numstrings; ++i)
{
this.strings[i] = TQData.ReadCString(reader);
if (outStream != null)
{
outStream.WriteLine("{0},{1}", i, this.strings[i]);
}
}
}
/// <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)
{
try
{
return(this.recordInfo[recordId].Decompress(this));
}
catch (KeyNotFoundException)
{
// record not found
return(null);
}
}
}
/// <summary>
/// Parses an item block within the file and coverts raw item data into internal item data
/// </summary>
/// <param name="fileOffset">Offset into the file</param>
/// <param name="reader">BinaryReader instance</param>
private void ParseItemBlock(int fileOffset, BinaryReader reader)
{
try
{
reader.BaseStream.Seek(fileOffset, SeekOrigin.Begin);
reader.ReadInt32();
TQData.ValidateNextString("begin_block", reader);
this.beginBlockCrap = reader.ReadInt32();
TQData.ValidateNextString("stashVersion", reader);
this.stashVersion = reader.ReadInt32();
TQData.ValidateNextString("fName", reader);
// Changed to raw data to support extended characters
int stringLength = reader.ReadInt32();
this.name = reader.ReadBytes(stringLength);
TQData.ValidateNextString("sackWidth", reader);
this.Width = reader.ReadInt32();
TQData.ValidateNextString("sackHeight", reader);
this.Height = reader.ReadInt32();
this.numberOfSacks = 1;
this.sack = new SackCollection();
this.sack.SackType = SackType.Stash;
this.sack.IsImmortalThrone = true;
this.sack.Parse(reader);
}
catch (ArgumentException)
{
// The ValidateNextString Method can throw an ArgumentException.
// We just pass it along at this point.
throw;
}
}
/// <summary>
/// Encodes the live equipment data into raw binary
/// </summary>
/// <returns>byte array holding the converted binary data</returns>
private byte[] EncodeEquipmentData()
{
int dataLength;
byte[] data;
// Encode the item data into a memory stream
using (MemoryStream writeStream = new MemoryStream(2048))
{
using (BinaryWriter writer = new BinaryWriter(writeStream))
{
if (this.IsImmortalThrone)
{
TQData.WriteCString(writer, "equipmentCtrlIOStreamVersion");
writer.Write(this.equipmentCtrlIOStreamVersion);
}
this.EquipmentSack.Encode(writer);
dataLength = (int)writeStream.Length;
}
// now just return the buffer we wrote to.
data = writeStream.GetBuffer();
}
// The problem is that ans() may be bigger than the amount of data in it.
// We need to resize the array
if (dataLength == data.Length)
{
return(data);
}
byte[] realData = new byte[dataLength];
Array.Copy(data, realData, dataLength);
return(realData);
}
/// <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>
/// Parses the item block
/// </summary>
/// <param name="offset">offset in the player file</param>
/// <param name="reader">BinaryReader instance</param>
private void ParseItemBlock(int offset, BinaryReader reader)
{
try
{
this.itemBlockStart = offset;
reader.BaseStream.Seek(offset, SeekOrigin.Begin);
TQData.ValidateNextString("numberOfSacks", reader);
this.numberOfSacks = reader.ReadInt32();
TQData.ValidateNextString("currentlyFocusedSackNumber", reader);
this.currentlyFocusedSackNumber = reader.ReadInt32();
TQData.ValidateNextString("currentlySelectedSackNumber", reader);
this.currentlySelectedSackNumber = reader.ReadInt32();
this.sacks = new SackCollection[this.numberOfSacks];
for (int i = 0; i < this.numberOfSacks; ++i)
{
this.sacks[i] = new SackCollection();
this.sacks[i].SackType = SackType.Sack;
this.sacks[i].IsImmortalThrone = this.IsImmortalThrone;
this.sacks[i].Parse(reader);
}
this.itemBlockEnd = (int)reader.BaseStream.Position;
}
catch (ArgumentException)
{
// The ValidateNextString Method can throw an ArgumentException.
// We just pass it along at this point.
throw;
}
}
/// <summary>
/// Parses the binary sack data to internal data
/// </summary>
/// <param name="reader">BinaryReader instance</param>
public void Parse(BinaryReader reader)
{
try
{
this.isModified = false;
if (this.sackType == SackType.Stash)
{
// IL decided to use a different format for the stash files.
TQData.ValidateNextString("numItems", reader);
this.size = reader.ReadInt32();
}
else if (this.sackType == SackType.Equipment)
{
if (this.isImmortalThrone)
{
this.size = 12;
this.slots = 12;
}
else
{
this.size = 11;
this.slots = 11;
}
}
else
{
// This is just a regular sack.
TQData.ValidateNextString("begin_block", reader); // make sure we just read a new block
this.beginBlockCrap = reader.ReadInt32();
TQData.ValidateNextString("tempBool", reader);
this.tempBool = reader.ReadInt32();
TQData.ValidateNextString("size", reader);
this.size = reader.ReadInt32();
}
this.items = new List <Item>(this.size);
Item prevItem = null;
for (int i = 0; i < this.size; ++i)
{
// Additional logic to decode the weapon slots in the equipment section
if (this.sackType == SackType.Equipment && (i == 7 || i == 9))
{
TQData.ValidateNextString("begin_block", reader);
this.beginBlockCrap = reader.ReadInt32();
// Eat the alternate tag and flag
TQData.ValidateNextString("alternate", reader);
// Skip over the alternateCrap
reader.ReadInt32();
}
Item item = new Item();
item.ContainerType = this.sackType;
item.Parse(reader);
// Stack this item with the previous item if necessary
if ((prevItem != null) && item.DoesStack && (item.PositionX == -1) && (item.PositionY == -1))
{
prevItem.StackSize++;
}
else
{
prevItem = item;
this.items.Add(item);
if (this.sackType == SackType.Equipment)
{
// Get the item location from the table
item.PositionX = GetEquipmentLocationOffset(i).X;
item.PositionY = GetEquipmentLocationOffset(i).Y;
// Eat the itemAttached tag and flag
TQData.ValidateNextString("itemAttached", reader);
// Skip over the itemAttachedCrap
reader.ReadInt32();
}
}
// Additional logic to decode the weapon slots in the equipment section
if (this.sackType == SackType.Equipment && (i == 8 || i == 10))
{
TQData.ValidateNextString("end_block", reader);
this.endBlockCrap = reader.ReadInt32();
}
}
TQData.ValidateNextString("end_block", reader);
this.endBlockCrap = reader.ReadInt32();
}
catch (ArgumentException)
{
// The ValidateNextString Method can throw an ArgumentException.
// We just pass it along at this point.
throw;
}
}
/// <summary>
/// Encodes the sack into binary form
/// </summary>
/// <param name="writer">BinaryWriter instance</param>
public void Encode(BinaryWriter writer)
{
if (this.sackType == SackType.Stash)
{
// Item stacks are stored as single items in the stash
TQData.WriteCString(writer, "numItems");
writer.Write(this.Count);
}
else if (this.sackType == SackType.Equipment)
{
// Nothing special except to skip all of the other header crap
// since the number of items is always fixed.
}
else
{
TQData.WriteCString(writer, "begin_block");
writer.Write(this.beginBlockCrap);
TQData.WriteCString(writer, "tempBool");
writer.Write(this.tempBool);
TQData.WriteCString(writer, "size");
writer.Write(this.CountTQItems());
}
int slotNumber = -1;
foreach (Item item in this)
{
++slotNumber;
item.ContainerType = this.sackType;
int itemAttached = 0;
int alternate = 0;
// Additional logic to encode the weapon slots in the equipment section
if (this.sackType == SackType.Equipment && (slotNumber == 7 || slotNumber == 9))
{
TQData.WriteCString(writer, "begin_block");
writer.Write(this.beginBlockCrap);
TQData.WriteCString(writer, "alternate");
if (slotNumber == 9)
{
// Only set the flag for the second set of weapons
alternate = 1;
}
else
{
// Otherwise set the flag to false.
alternate = 0;
}
writer.Write(alternate);
}
item.Encode(writer);
if (this.sackType == SackType.Equipment)
{
TQData.WriteCString(writer, "itemAttached");
if (!string.IsNullOrEmpty(item.BaseItemId) && slotNumber != 9 && slotNumber != 10)
{
// If there is an item in this slot, set the flag.
// Unless it's in the secondary weapon slot.
itemAttached = 1;
}
else
{
// This is only a dummy item so we do not set the flag.
itemAttached = 0;
}
writer.Write(itemAttached);
}
// Additional logic to encode the weapon slots in the equipment section
if (this.sackType == SackType.Equipment && (slotNumber == 8 || slotNumber == 10))
{
TQData.WriteCString(writer, "end_block");
writer.Write(this.endBlockCrap);
}
}
TQData.WriteCString(writer, "end_block");
writer.Write(this.endBlockCrap);
}
/// <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)
{
TQDebug.DebugWriteLine(string.Format(CultureInfo.InvariantCulture, "ARCFile.GetData({0})", dataId));
}
if (!this.fileHasBeenRead)
{
this.ReadARCToC();
}
if (this.directoryEntries == null)
{
if (TQDebug.ArcFileDebugLevel > 1)
{
TQDebug.DebugWriteLine(string.Format(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)
{
TQDebug.DebugWriteLine(string.Format(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)
{
TQDebug.DebugWriteLine(string.Format(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)
{
TQDebug.DebugWriteLine(string.Format(
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)
{
TQDebug.DebugWriteLine("Exiting ARCFile.GetData()");
}
return(data);
}
}
/// <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)
{
TQDebug.DebugWriteLine(string.Format(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)
{
TQDebug.DebugWriteLine(string.Format(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)
{
TQDebug.DebugWriteLine(string.Format(CultureInfo.InvariantCulture, "numEntries={0}, numParts={1}", numEntries, numParts));
}
ARCPartEntry[] parts = new ARCPartEntry[numParts];
ARCDirEntry[] records = new ARCDirEntry[numEntries];
if (TQDebug.ArcFileDebugLevel > 2)
{
TQDebug.DebugWriteLine("Seeking to tocOffset location");
}
reader.BaseStream.Seek(0x18, SeekOrigin.Begin);
int tocOffset = reader.ReadInt32();
if (TQDebug.ArcFileDebugLevel > 1)
{
TQDebug.DebugWriteLine(string.Format(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)
{
TQDebug.DebugWriteLine(string.Format(CultureInfo.InvariantCulture, "parts[{0}]", i));
TQDebug.DebugWriteLine(string.Format(
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)
{
TQDebug.DebugWriteLine(string.Format(
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)
{
TQDebug.DebugWriteLine(string.Format(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)
{
TQDebug.DebugWriteLine(string.Format(CultureInfo.InvariantCulture, "Crap2={0}", crap));
}
crap = reader.ReadInt32(); // crap
if (TQDebug.ArcFileDebugLevel > 2)
{
TQDebug.DebugWriteLine(string.Format(CultureInfo.InvariantCulture, "Crap3={0}", crap));
}
crap = reader.ReadInt32(); // crap
if (TQDebug.ArcFileDebugLevel > 2)
{
TQDebug.DebugWriteLine(string.Format(CultureInfo.InvariantCulture, "Crap4={0}", crap));
}
int numberOfParts = reader.ReadInt32();
if (numberOfParts < 1)
{
records[i].Parts = null;
if (TQDebug.ArcFileDebugLevel > 2)
{
TQDebug.DebugWriteLine(string.Format(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)
{
TQDebug.DebugWriteLine(string.Format(CultureInfo.InvariantCulture, "Filename Length={0}", crap));
}
crap = reader.ReadInt32(); // filename offset
if (TQDebug.ArcFileDebugLevel > 2)
{
TQDebug.DebugWriteLine(string.Format(CultureInfo.InvariantCulture, "Filename Offset={0}", crap));
TQDebug.DebugWriteLine(string.Format(CultureInfo.InvariantCulture, "record[{0}]", i));
TQDebug.DebugWriteLine(string.Format(
CultureInfo.InvariantCulture,
" offset={0} compressedSize={1} realSize={2}",
records[i].FileOffset,
records[i].CompressedSize,
records[i].RealSize));
if (storageType != 1 && records[i].IsActive)
{
TQDebug.DebugWriteLine(string.Format(
CultureInfo.InvariantCulture,
" numParts={0} firstPart={1} lastPart={2}",
records[i].Parts.Length,
firstPart,
firstPart + records[i].Parts.Length - 1));
}
else
{
TQDebug.DebugWriteLine(string.Format(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)
{
TQDebug.DebugWriteLine(string.Format(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)
{
TQDebug.DebugWriteLine("Null file - inactive?");
}
break;
}
if (bufferSize >= buffer.Length)
{
TQDebug.DebugWriteLine("ARCFile.ReadARCToC() Error - Buffer size of 2048 has been exceeded.");
if (TQDebug.ArcFileDebugLevel > 2)
{
TQDebug.DebugWriteLine("Buffer contents:\n");
for (int j = 0; j < bufferSize; ++j)
{
TQDebug.DebugWrite(string.Format(CultureInfo.InvariantCulture, "0x{0:X}", buffer[j]));
}
TQDebug.DebugWriteLine(String.Empty);
}
}
}
if (TQDebug.ArcFileDebugLevel > 2)
{
TQDebug.DebugWriteLine(string.Format(
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)
{
TQDebug.DebugWriteLine(string.Format(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)
{
TQDebug.DebugWriteLine("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)
{
TQDebug.DebugWriteLine("Exiting ARCFile.ReadARCToC()");
}
}
}
}
catch (IOException exception)
{
// Turn on debugging.
if (!TQDebug.DebugEnabled)
{
TQDebug.DebugEnabled = true;
}
// Write the errors to the debug log.
TQDebug.DebugWriteLine("ARCFile.ReadARCToC() - Error reading arcfile");
TQDebug.DebugWriteLine(exception.ToString());
}
}
/// <summary>
/// Parses the raw binary data for use within TQVault
/// </summary>
private void ParseRawData()
{
// First create a memory stream so we can decode the binary data as needed.
using (MemoryStream stream = new MemoryStream(this.rawData, false))
{
using (BinaryReader reader = new BinaryReader(stream))
{
// Find the block pairs until we find the block that contains the item data.
int blockNestLevel = 0;
int currentOffset = 0;
int itemOffset = 0;
int equipmentOffset = 0;
// vaults start at the item data with no crap
bool foundItems = this.IsVault;
bool foundEquipment = this.IsVault;
while ((!foundItems || !foundEquipment) && (currentOffset = this.FindNextBlockDelim(currentOffset)) != -1)
{
if (this.rawData[currentOffset] == beginBlockPattern[0])
{
// begin block
++blockNestLevel;
currentOffset += beginBlockPattern.Length;
// skip past the 4 bytes of noise after begin_block
currentOffset += 4;
// Seek our stream to the correct position
stream.Seek(currentOffset, SeekOrigin.Begin);
// Now get the string for this block
string blockName = TQData.ReadCString(reader).ToUpperInvariant();
// Assign loc to our new stream position
currentOffset = (int)stream.Position;
// See if we accidentally got a begin_block or end_block
if (blockName.Equals("BEGIN_BLOCK"))
{
blockName = "(NONAME)";
currentOffset -= beginBlockPattern.Length;
}
else if (blockName.Equals("END_BLOCK"))
{
blockName = "(NONAME)";
currentOffset -= endBlockPattern.Length;
}
else if (blockName.Equals("ITEMPOSITIONSSAVEDASGRIDCOORDS"))
{
currentOffset += 4;
itemOffset = currentOffset; // skip value for itemPositionsSavedAsGridCoords
foundItems = true;
}
else if (blockName.Equals("USEALTERNATE"))
{
currentOffset += 4;
equipmentOffset = currentOffset; // skip value for useAlternate
foundEquipment = true;
}
// Print the string with a nesting level indicator
////string levelString = new string ('-', System.Math.Max(0,blockNestLevel*2-2));
////out.WriteLine ("{0} {2:n0} '{1}'", levelString, blockName, loc);
}
else
{
// end block
--blockNestLevel;
currentOffset += endBlockPattern.Length;
////if (blockNestLevel < 0)
////{
//// out.WriteLine ("{0:n0} Block Nest Level < 0!!!", loc);
////}
}
}
////out.WriteLine ("Final Block Level = {0:n0}", blockNestLevel);
if (foundItems)
{
try
{
this.ParseItemBlock(itemOffset, reader);
}
catch (ArgumentException exception)
{
if (!TQDebug.DebugEnabled)
{
TQDebug.DebugEnabled = true;
}
TQDebug.DebugWriteLine(string.Format(CultureInfo.InvariantCulture, "Error parsing player file Item Block - '{0}'", this.PlayerName));
TQDebug.DebugWriteLine(exception.ToString());
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Error parsing player file Item Block- '{0}'", this.PlayerName), exception);
}
try
{
string outfile = string.Concat(Path.Combine(TQData.TQVaultSaveFolder, this.PlayerName), " Export.txt");
using (StreamWriter outStream = new StreamWriter(outfile, false))
{
outStream.WriteLine("Number of Sacks = {0}", this.numberOfSacks);
int sackNumber = 0;
foreach (SackCollection sack in this.sacks)
{
if (!sack.IsEmpty)
{
outStream.WriteLine();
outStream.WriteLine("SACK {0}", sackNumber);
int itemNumber = 0;
foreach (Item item in sack)
{
object[] params1 = new object[20];
params1[0] = itemNumber;
params1[1] = item.ToString();
params1[2] = item.PositionX;
params1[3] = item.PositionY;
params1[4] = item.Seed;
////params1[5] =
outStream.WriteLine(" {0,5:n0} {1}", params1);
itemNumber++;
}
}
sackNumber++;
}
}
}
catch (IOException exception)
{
if (!TQDebug.DebugEnabled)
{
TQDebug.DebugEnabled = true;
}
TQDebug.DebugWriteLine(string.Format(
CultureInfo.InvariantCulture,
"Error writing Export file - '{0}'",
string.Concat(Path.Combine(TQData.TQVaultSaveFolder, this.PlayerName), " Export.txt")));
TQDebug.DebugWriteLine(exception.ToString());
}
}
// Process the equipment block
if (foundEquipment && !this.IsVault)
{
try
{
this.ParseEquipmentBlock(equipmentOffset, reader);
}
catch (ArgumentException exception)
{
if (!TQDebug.DebugEnabled)
{
TQDebug.DebugEnabled = true;
}
TQDebug.DebugWriteLine(string.Format(CultureInfo.InvariantCulture, "Error parsing player file Equipment Block - '{0}'", this.PlayerName));
TQDebug.DebugWriteLine(exception.ToString());
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Error parsing player file Equipment Block - '{0}'", this.PlayerName), exception);
}
try
{
string outfile = string.Concat(Path.Combine(TQData.TQVaultSaveFolder, this.PlayerName), " Equipment Export.txt");
using (StreamWriter outStream = new StreamWriter(outfile, false))
{
if (!this.EquipmentSack.IsEmpty)
{
int itemNumber = 0;
foreach (Item item in this.EquipmentSack)
{
object[] params1 = new object[20];
params1[0] = itemNumber;
params1[1] = item.ToString();
params1[2] = item.PositionX;
params1[3] = item.PositionY;
params1[4] = item.Seed;
////params1[5] =
outStream.WriteLine(" {0,5:n0} {1}", params1);
itemNumber++;
}
}
}
}
catch (IOException exception)
{
if (!TQDebug.DebugEnabled)
{
TQDebug.DebugEnabled = true;
}
TQDebug.DebugWriteLine(string.Format(
CultureInfo.InvariantCulture,
"Error writing Export file - '{0}'",
string.Concat(Path.Combine(TQData.TQVaultSaveFolder, this.PlayerName), " Equipment Export.txt")));
TQDebug.DebugWriteLine(exception.ToString());
}
}
}
}
}
