public static Compression.IHyoutaArchiveCompressionInfo?Deserialize(DuplicatableStream stream, long maxBytes, EndianUtils.Endianness endian)
{
if (maxBytes < 8)
{
stream.DiscardBytes(maxBytes);
return(null);
}
ulong identifier = stream.ReadUInt64(EndianUtils.Endianness.BigEndian);
switch (identifier)
{
case 0:
// archive has compression, but this file is not compressed
stream.DiscardBytes(maxBytes - 8);
return(null);
case DeflateSharpCompressionInfo.Identifier:
return(DeflateSharpCompressionInfo.Deserialize(stream, maxBytes - 8, endian));
default:
Console.WriteLine("Unknown compression type: " + identifier.ToString("x16"));
stream.DiscardBytes(maxBytes - 8);
return(null);
}
}
public static DeflateSharpCompressionInfo?Deserialize(DuplicatableStream stream, long maxBytes, EndianUtils.Endianness endian)
{
// note: identifier has already been read
if (maxBytes < 8)
{
stream.DiscardBytes(maxBytes);
return(null);
}
ulong uncompressedFilesize = stream.ReadUInt64(endian);
stream.DiscardBytes(maxBytes - 8);
return(new DeflateSharpCompressionInfo(uncompressedFilesize));
}
private static string?ReadString(DuplicatableStream s, uint maxBytes, EndianUtils.Endianness e)
{
if (maxBytes < 8)
{
// can't be a valid string
s.DiscardBytes(maxBytes);
return(null);
}
ulong rawlength = s.ReadUInt64(e);
ulong length = (rawlength & 0x7ffffffffffffffful);
bool hasOffset = (rawlength & 0x8000000000000000ul) > 0;
if (hasOffset)
{
// format is 8 bytes length, then 8 bytes position of string in data
if (maxBytes < 16)
{
// can't be valid
s.DiscardBytes(maxBytes - 8);
return(null);
}
ulong offset = s.ReadUInt64(e);
long p = s.Position + (maxBytes - 16);
s.Position = (long)offset;
string str = s.ReadSizedString((long)length, TextUtils.GameTextEncoding.UTF8);
s.Position = p;
return(str);
}
else
{
// format is 8 bytes length, then [number read] bytes string
uint restBytes = maxBytes - 8;
if (length > restBytes)
{
// can't be a valid string
s.DiscardBytes(restBytes);
return(null);
}
string str = s.ReadSizedString((long)length, TextUtils.GameTextEncoding.UTF8);
s.DiscardBytes(restBytes - length);
return(str);
}
}
public static HyoutaArchiveBpsPatchInfo?Deserialize(DuplicatableStream stream, long maxBytes, EndianUtils.Endianness endian, ulong currentFileIndex, HyoutaArchiveChunk referencedChunk)
{
if (maxBytes < 16)
{
stream.DiscardBytes(maxBytes);
return(null);
}
else
{
ulong fileIndexToPatch = stream.ReadUInt64(endian);
ulong targetFilesize = stream.ReadUInt64(endian);
stream.DiscardBytes(maxBytes - 16);
if (fileIndexToPatch == currentFileIndex)
{
// this is how you set a file to be unpatched in an archive that has patches
return(null);
}
else
{
return(new HyoutaArchiveBpsPatchInfo(fileIndexToPatch, targetFilesize, referencedChunk));
}
}
}
public void PrintData(EndianUtils.Endianness endian, Dictionary <uint, TSS.TSSEntry> inGameDic, List <ItemDat.ItemDatSingle> itemDataSorted, T8BTEMST.T8BTEMST enemies)
{
using (DuplicatableStream stream = Stream.Duplicate()) {
stream.ReadUInt32().FromEndian(endian); // ?
stream.ReadUInt32().FromEndian(endian); // ?
stream.ReadUInt32Array(9, endian);
stream.ReadUInt32().FromEndian(endian); // play time in frames, assuming 60 frames = 1 second
stream.ReadUInt32().FromEndian(endian); // gald
stream.DiscardBytes(4); // ?
uint[] itemCounts = stream.ReadUInt32Array(3072, endian);
uint[] itemBookBitfields = stream.ReadUInt32Array(3072 / 32, endian);
stream.DiscardBytes(4); // ?
stream.ReadUInt32Array(4, endian); // control modes for the four active party slots
stream.ReadUInt32Array(3, endian); // strategies assigned to dpad directions
stream.DiscardBytes(0x40); // ??
for (int i = 0; i < 8; ++i)
{
// custom strategy names
// game seems to read these till null byte so this could totally be abused to buffer overflow...
stream.ReadAscii(0x40);
}
stream.DiscardBytes(0xA84D0 - 0xA7360); // ?
uint[] monsterBookBitfieldsScanned = stream.ReadUInt32Array(0x48 / 4, endian);
stream.DiscardBytes(0xA8680 - 0xA8518); // ?
uint[] monsterBookBitfieldsSeen = stream.ReadUInt32Array(0x48 / 4, endian);
stream.DiscardBytes(0xA8928 - 0xA86C8); // ?
uint collectorsBookIndex = 0;
foreach (var item in itemDataSorted)
{
uint i = item.Data[(int)ItemDat.ItemData.ID];
if (item.Data[(int)ItemDat.ItemData.InCollectorsBook] > 0)
{
bool haveItem = ((itemBookBitfields[i / 32] >> (int)(i % 32)) & 1) > 0;
Console.WriteLine((haveItem ? "Y" : "N") + (collectorsBookIndex) + ": " + inGameDic[item.NamePointer].StringEngOrJpn);
++collectorsBookIndex;
}
}
uint monsterBookIndex = 0;
foreach (var enemy in enemies.EnemyList)
{
uint i = enemy.InGameID;
if (enemy.InMonsterBook > 0)
{
bool haveSeen = ((monsterBookBitfieldsSeen[i / 32] >> (int)(i % 32)) & 1) > 0;
bool haveScanned = ((monsterBookBitfieldsScanned[i / 32] >> (int)(i % 32)) & 1) > 0;
Console.WriteLine((haveSeen ? "Y" : "N") + (haveScanned ? "Y" : "N") + (monsterBookIndex) + ": " + inGameDic[enemy.NameStringDicID].StringEngOrJpn);
++monsterBookIndex;
}
}
}
}
public HyoutaArchiveChunk(DuplicatableStream duplicatableStream, out ulong chunkLength)
{
using (DuplicatableStream data = duplicatableStream.Duplicate()) {
data.Position = 0;
// header
ulong extraMagic = data.ReadUInt64(EndianUtils.Endianness.LittleEndian);
ulong magic = extraMagic & 0x00fffffffffffffful;
if (magic != 0x6b6e7568636168)
{
throw new Exception("wrong magic");
}
byte extra = (byte)((extraMagic >> 56) & 0xffu);
byte packedAlignment = (byte)(extra & 0x1fu);
long unpackedAlignment = 1L << packedAlignment;
bool hasMetadata = (extra & 0x20) != 0;
bool isCompressed = (extra & 0x40) != 0;
bool isBigEndian = (extra & 0x80) != 0;
EndianUtils.Endianness e = isBigEndian ? EndianUtils.Endianness.BigEndian : EndianUtils.Endianness.LittleEndian;
ulong endOfFileOffset = data.ReadUInt64(e) << packedAlignment;
ulong tableOfContentsOffset = data.ReadUInt64(e) << packedAlignment;
ulong filecount = data.ReadUInt64(e);
chunkLength = endOfFileOffset;
if (hasMetadata)
{
// just skip past this for now
ulong metadataLength = data.ReadUInt64(e);
data.DiscardBytes(metadataLength);
}
DuplicatableStream dataBlockStream;
if (isCompressed)
{
ushort compressionInfoLengthRaw = data.ReadUInt16(e);
uint compressionInfoLength = compressionInfoLengthRaw & 0xfffcu;
int compressionInfoAlignmentPacked = (compressionInfoLengthRaw & 0x3) + 1;
data.ReadAlign(1u << compressionInfoAlignmentPacked);
Compression.IHyoutaArchiveCompressionInfo?compressionInfo = HyoutaArchiveCompression.Deserialize(data, compressionInfoLength == 0 ? 0x10000u : compressionInfoLength, e);
if (compressionInfo == null)
{
throw new Exception("File is indicated to be compressed, but no decompressor found.");
}
dataBlockStream = compressionInfo.Decompress(data);
}
else
{
data.ReadAlign(unpackedAlignment);
dataBlockStream = new PartialStream(data, data.Position, (long)(endOfFileOffset - (ulong)data.Position));
}
try {
data.Dispose();
dataBlockStream.Position = (long)tableOfContentsOffset;
uint offsetToFirstFileInfo = ReadContentLength(dataBlockStream, e);
// decode content bitfield(s)
long numberOfUnknownBits = 0;
ushort contentBitfield1 = dataBlockStream.ReadUInt16(e);
bool hasDummyContent = (contentBitfield1 & 0x0001u) != 0;
bool hasFilename = (contentBitfield1 & 0x0002u) != 0;
bool hasCompression = (contentBitfield1 & 0x0004u) != 0;
bool hasBpsPatch = (contentBitfield1 & 0x0008u) != 0;
bool hasCrc32 = (contentBitfield1 & 0x0010u) != 0;
bool hasMd5 = (contentBitfield1 & 0x0020u) != 0;
bool hasSha1 = (contentBitfield1 & 0x0040u) != 0;
numberOfUnknownBits += (contentBitfield1 & 0x0080u) != 0 ? 1 : 0;
numberOfUnknownBits += (contentBitfield1 & 0x0100u) != 0 ? 1 : 0;
numberOfUnknownBits += (contentBitfield1 & 0x0200u) != 0 ? 1 : 0;
numberOfUnknownBits += (contentBitfield1 & 0x0400u) != 0 ? 1 : 0;
numberOfUnknownBits += (contentBitfield1 & 0x0800u) != 0 ? 1 : 0;
numberOfUnknownBits += (contentBitfield1 & 0x1000u) != 0 ? 1 : 0;
numberOfUnknownBits += (contentBitfield1 & 0x2000u) != 0 ? 1 : 0;
numberOfUnknownBits += (contentBitfield1 & 0x4000u) != 0 ? 1 : 0;
ushort currentBitfield = contentBitfield1;
while ((currentBitfield & 0x8000u) != 0)
{
// more bitfields, though we don't understand them since only the first handful of bits are defined at the moment, so just count and skip them
currentBitfield = dataBlockStream.ReadUInt16(e);
numberOfUnknownBits += (currentBitfield & 0x0001u) != 0 ? 1 : 0;
numberOfUnknownBits += (currentBitfield & 0x0002u) != 0 ? 1 : 0;
numberOfUnknownBits += (currentBitfield & 0x0004u) != 0 ? 1 : 0;
numberOfUnknownBits += (currentBitfield & 0x0008u) != 0 ? 1 : 0;
numberOfUnknownBits += (currentBitfield & 0x0010u) != 0 ? 1 : 0;
numberOfUnknownBits += (currentBitfield & 0x0020u) != 0 ? 1 : 0;
numberOfUnknownBits += (currentBitfield & 0x0040u) != 0 ? 1 : 0;
numberOfUnknownBits += (currentBitfield & 0x0080u) != 0 ? 1 : 0;
numberOfUnknownBits += (currentBitfield & 0x0100u) != 0 ? 1 : 0;
numberOfUnknownBits += (currentBitfield & 0x0200u) != 0 ? 1 : 0;
numberOfUnknownBits += (currentBitfield & 0x0400u) != 0 ? 1 : 0;
numberOfUnknownBits += (currentBitfield & 0x0800u) != 0 ? 1 : 0;
numberOfUnknownBits += (currentBitfield & 0x1000u) != 0 ? 1 : 0;
numberOfUnknownBits += (currentBitfield & 0x2000u) != 0 ? 1 : 0;
numberOfUnknownBits += (currentBitfield & 0x4000u) != 0 ? 1 : 0;
}
uint dummyContentLength = hasDummyContent ? ReadContentLength(dataBlockStream, e) : 0;
uint filenameLength = hasFilename ? ReadContentLength(dataBlockStream, e) : 0;
uint compressionLength = hasCompression ? ReadContentLength(dataBlockStream, e) : 0;
uint bpspatchLength = hasBpsPatch ? ReadContentLength(dataBlockStream, e) : 0;
uint crc32Length = hasCrc32 ? ReadContentLength(dataBlockStream, e) : 0;
uint md5Length = hasMd5 ? ReadContentLength(dataBlockStream, e) : 0;
uint sha1Length = hasSha1 ? ReadContentLength(dataBlockStream, e) : 0;
long unknownContentLength = 0;
for (long i = 0; i < numberOfUnknownBits; ++i)
{
unknownContentLength += ReadContentLength(dataBlockStream, e);
}
dataBlockStream.Position = (long)(tableOfContentsOffset + offsetToFirstFileInfo);
List <HyoutaArchiveFileInfo> files = new List <HyoutaArchiveFileInfo>((int)filecount);
for (ulong i = 0; i < filecount; ++i)
{
ulong offset = dataBlockStream.ReadUInt64(e) << packedAlignment;
ulong filesize = dataBlockStream.ReadUInt64(e);
HyoutaArchiveFileInfo fi = new HyoutaArchiveFileInfo();
if (hasDummyContent)
{
fi.DummyContent = dataBlockStream.ReadBytes(dummyContentLength);
}
if (hasFilename)
{
fi.Filename = ReadString(dataBlockStream, filenameLength, e);
}
if (hasCompression)
{
fi.CompressionInfo = HyoutaArchiveCompression.Deserialize(dataBlockStream, compressionLength, e);
fi.StreamIsCompressed = true;
}
if (hasBpsPatch)
{
fi.BpsPatchInfo = HyoutaArchiveBpsPatchInfo.Deserialize(dataBlockStream, bpspatchLength, e, i, this);
fi.StreamIsBpsPatch = fi.BpsPatchInfo != null;
}
if (hasCrc32)
{
if (crc32Length >= 4)
{
fi.crc32 = new CRC32(dataBlockStream.ReadUInt32(EndianUtils.Endianness.BigEndian));
dataBlockStream.DiscardBytes(crc32Length - 4);
}
else
{
dataBlockStream.DiscardBytes(crc32Length);
}
}
if (hasMd5)
{
if (md5Length >= 16)
{
ulong a = dataBlockStream.ReadUInt64(EndianUtils.Endianness.BigEndian);
ulong b = dataBlockStream.ReadUInt64(EndianUtils.Endianness.BigEndian);
fi.md5 = new MD5(a, b);
dataBlockStream.DiscardBytes(md5Length - 16);
}
else
{
dataBlockStream.DiscardBytes(md5Length);
}
}
if (hasSha1)
{
if (sha1Length >= 20)
{
ulong a = dataBlockStream.ReadUInt64(EndianUtils.Endianness.BigEndian);
ulong b = dataBlockStream.ReadUInt64(EndianUtils.Endianness.BigEndian);
uint c = dataBlockStream.ReadUInt32(EndianUtils.Endianness.BigEndian);
fi.sha1 = new SHA1(a, b, c);
dataBlockStream.DiscardBytes(sha1Length - 20);
}
else
{
dataBlockStream.DiscardBytes(sha1Length);
}
}
dataBlockStream.DiscardBytes(unknownContentLength);
fi.Data = new PartialStream(dataBlockStream, (long)offset, (long)filesize);
files.Add(fi);
}
Files = files;
} finally {
dataBlockStream.Dispose();
}
}
}