/// <summary>
/// Voices
/// </summary>
public void WriteStage8(ExtendedBinaryWriter writer)
{
writer.FillInOffset("Manual_Ptr_7l", true, false);
int i = 0;
foreach (var entry in _voices)
{
writer.AddOffset($"UnknownName{i}");
writer.AddOffset($"KnownName{i}");
writer.AddOffset($"PreferedName{i}");
writer.Write(entry.ID);
++i;
}
writer.FillInOffset("Manual_Ptr_7h", true, false);
i = 0;
foreach (var entry in _voices)
{
writer.FillInOffset($"UnknownName{i}");
writer.WriteNullTerminatedString(entry.UnknownName);
writer.FillInOffset($"KnownName{i}");
writer.WriteNullTerminatedString(entry.KnownName);
writer.FillInOffset($"PreferedName{i}");
writer.WriteNullTerminatedString(entry.PreferedName);
++i;
}
writer.FixPadding(0x4);
}
/// <summary>
/// ArtBook Pages
/// </summary>
public void WriteStage10(ExtendedBinaryWriter writer)
{
writer.FillInOffset("Manual_Ptr_9l", true, false);
int i = 0;
foreach (var entry in _artBookPages)
{
writer.AddOffset($"PagePathThumbnail{i}");
writer.AddOffset($"PagePathData{i}");
writer.AddOffset($"Name{i}");
writer.Write(entry.ID);
writer.Write((short)entry.GameID);
writer.Write(entry.Page);
++i;
}
writer.FillInOffset("Manual_Ptr_9h", true, false);
i = 0;
foreach (var entry in _artBookPages)
{
writer.FillInOffset($"PagePathThumbnail{i}");
writer.WriteNullTerminatedString(entry.PagePathThumbnail);
writer.FillInOffset($"PagePathData{i}");
writer.WriteNullTerminatedString(entry.PagePathData);
writer.FillInOffset($"Name{i}");
writer.WriteNullTerminatedString(entry.Name);
++i;
}
writer.FixPadding(0x4);
}
/// <summary>
/// Memories
/// </summary>
public void WriteStage4(ExtendedBinaryWriter writer)
{
writer.FillInOffset("Manual_Ptr_3l", true, false);
int i = 0;
foreach (var entry in _memories)
{
writer.AddOffset($"MemName{i}");
writer.AddOffset($"MemDesc{i}");
writer.Write(entry.ID);
writer.Write((byte)entry.GameID);
writer.Write((byte)entry.Game);
writer.Write((short)0); // Padding
++i;
}
writer.FillInOffset("Manual_Ptr_3h", true, false);
i = 0;
foreach (var entry in _memories)
{
writer.FillInOffset($"MemName{i}");
writer.WriteNullTerminatedString(entry.Name);
writer.FillInOffset($"MemDesc{i}");
writer.WriteNullTerminatedString(entry.Description);
++i;
}
writer.FixPadding(0x4);
}
/// <summary>
/// Movies
/// </summary>
public void WriteStage3(ExtendedBinaryWriter writer)
{
writer.FillInOffset("Manual_Ptr_2l", true, false);
int i = 0;
foreach (var entry in _movies)
{
writer.AddOffset($"Name{i}");
writer.AddOffset($"Path{i}");
writer.Write(entry.ID);
writer.Write(entry.Unknown4);
writer.Write((byte)entry.GameID);
writer.Write(entry.Unknown5);
++i;
}
writer.FillInOffset("Manual_Ptr_2h", true, false);
i = 0;
foreach (var entry in _movies)
{
writer.FillInOffset($"Name{i}");
writer.WriteNullTerminatedString(entry.FriendlyName);
writer.FillInOffset($"Path{i}");
writer.WriteNullTerminatedString(entry.FilePath);
++i;
}
writer.FixPadding(0x4);
}
public override void Save(Stream fileStream)
{
var writer = new ExtendedBinaryWriter(fileStream, false);
// TODO
writer.AddOffset("crc32"); // CRC32?
writer.Write(Data.Count);
var fileDatas = new List <byte[]>();
int i = 0;
foreach (ArchiveFile file in Data)
{
var fileNameBuffer = new char[0x40];
file.Name.CopyTo(0, fileNameBuffer, 0, file.Name.Length);
writer.Write(fileNameBuffer);
var fileData = file.Data;
writer.Write(fileData.Length); // Uncompressed Size
writer.Write(fileData.Length); // Compressed Size
writer.AddOffset("fileOffset" + i); // File Offset
writer.Write(0u); // Is Compressed 0 = FALSE, 1 = TRUE
fileDatas.Add(fileData);
++i;
}
for (i = 0; i < fileDatas.Count; ++i)
{
writer.FillInOffset("fileOffset" + i);
writer.Write(fileDatas[i]);
}
// TODO
writer.FillInOffset("crc32", 0u);
}
/// <summary>
/// Druma CD
/// </summary>
public void WriteStage11(ExtendedBinaryWriter writer)
{
writer.FillInOffset("Manual_Ptr_10l", true, false);
int i = 0;
foreach (var entry in _dramaCDs)
{
writer.AddOffset($"FileName{i}");
writer.AddOffset($"FriendlyName{i}");
writer.AddOffset($"SourceAlbum{i}");
writer.AddOffset($"InternalName{i}");
writer.Write(entry.ID);
writer.Write((short)entry.Game);
writer.Write(entry.Unknown7);
writer.Write(entry.SourceTrackID);
writer.Write(entry.Unknown9);
++i;
}
writer.FillInOffset("Manual_Ptr_10h", true, false);
i = 0;
foreach (var entry in _dramaCDs)
{
writer.FillInOffset($"FileName{i}");
writer.WriteNullTerminatedString(entry.FileName);
writer.FillInOffset($"FriendlyName{i}");
writer.WriteNullTerminatedString(entry.FriendlyName);
writer.FillInOffset($"SourceAlbum{i}");
writer.WriteNullTerminatedString(entry.SourceAlbum);
writer.FillInOffset($"InternalName{i}");
writer.WriteNullTerminatedString(entry.InternalName);
++i;
}
writer.FixPadding(0x4);
}
// TODO
protected void SaveShadowArchive(ExtendedBinaryWriter writer)
{
var files = GetFiles(false);
bool isVersion6 = (Magic == (uint)Magics.Shadow6);
string version = isVersion6 ? "One Ver 0.60" : "One Ver 0.50";
int maxNameLength = isVersion6 ? 0x2C : 0x20; // The max file name size
writer.Write(0); // Padding
writer.AddOffset("fileSize"); // File Size (will be overwritten later)
writer.Write(Magic); // Magic
writer.WriteSignature(version); // Version String
writer.Write(0); // Unknown
writer.Write(files.Count);
writer.Write(0xCDCDCD00); // Null Terminated String?
for (int i = 0; i < 7; ++i)
{
writer.Write(0xCDCDCDCD);
}
writer.WriteNulls(0x70); // Skip two entries?
// Write File Information
for (int i = 0; i < files.Count; ++i)
{
var file = files[i];
// File Name
var fileName = new char[maxNameLength];
file.Name.CopyTo(0, fileName, 0,
(file.Name.Length > maxNameLength) ?
maxNameLength : file.Name.Length);
writer.Write(fileName); // File Name
writer.Write(file.Data.Length); // Uncompressed File Size
writer.AddOffset("fileDataOffset" + i); // Data Offset
writer.Write(1); // Unknown
if (!isVersion6)
{
writer.WriteNulls(0xC); // Unknown
}
}
writer.WriteNulls(0x14); // Unknown, Probably not required
// Write File Data
for (int i = 0; i < files.Count; ++i)
{
// Data Offset
writer.FillInOffset($"fileDataOffset{i}",
(uint)writer.BaseStream.Position - 0xC);
// TODO: Compress File Data with PRS
writer.Write(files[i].Data); // Write File data
}
writer.FillInOffset("fileSize", (uint)writer.BaseStream.Position - 0xC);
}
public static void WriteByType(ExtendedBinaryWriter writer, ArgumentType type, object value, ref int manualCount, List <string> strings = null)
{
switch (type)
{
case AT_Bool:
writer.Write((bool)value);
break;
case AT_Byte:
writer.Write((byte)value);
break;
case AT_Int16:
writer.Write((short)value);
break;
case AT_Int32:
writer.Write((int)value);
break;
case AT_Float:
writer.Write((float)value);
break;
case AT_String:
if (strings == null)
{
break;
}
writer.AddOffset($"Strings_{strings.Count}");
strings.Add((string)value);
break;
case AT_StringPtr:
if (strings == null)
{
break;
}
writer.AddOffset($"StringsPtr_{strings.Count}");
strings.Add((string)value);
break;
case AT_CodePointer:
writer.Write((int)value);
break;
case AT_DataReference:
writer.Write((int)value);
break;
case AT_DataBlock:
writer.AddOffset($"Manual_Ptr_{manualCount}l");
writer.AddOffset($"Manual_Ptr_{manualCount}h");
++manualCount;
break;
}
}
public void Write(ExtendedBinaryWriter writer, string offsetSuffix = "")
{
writer.AddOffset($"texNameOffset{offsetSuffix}");
writer.Write(TexFlags);
writer.AddOffset($"texTypeOffset{offsetSuffix}");
// Texture Name
writer.FillInOffset($"texNameOffset{offsetSuffix}", false, false);
writer.WriteNullTerminatedString(TextureName);
// Texture Type
writer.FillInOffset($"texTypeOffset{offsetSuffix}", false, false);
writer.WriteNullTerminatedString(Type);
writer.FixPadding(4);
}
public override void Save(ExtendedBinaryWriter writer)
{
var strings = new List <string>();
writer.WriteSignature("STSC");
writer.AddOffset("EntryPosition");
writer.Write(0x07); // Version
writer.WriteSignature(ScriptName);
writer.WriteNulls((uint)(0x20 - ScriptName.Length)); // Pad Script Name
writer.Write(0x000507E3);
writer.Write((short)0x09);
writer.Write((short)0x0D);
writer.Write((short)0x19);
writer.Write((short)0x0D);
writer.Write(ScriptID);
writer.FillInOffset("EntryPosition");
foreach (var instruction in Instructions)
{
writer.Write((byte)STSCInstructions.DALRRInstructions.FindIndex(t => t?.Name == instruction.Name));
instruction.Write(writer, ref ManualCount, strings);
}
// Write String Table
for (int i = 0; i < strings.Count; ++i)
{
writer.FillInOffset($"Strings_{i}");
writer.WriteNullTerminatedString(strings[i]);
}
writer.FixPadding(0x10);
}
public int Save(Stream fileStream, uint?sizeLimit, int startIndex = 0)
{
// Header
var files = GetFiles(false);
var writer = new ExtendedBinaryWriter(fileStream, Encoding.ASCII, false);
writer.Write(Sig1);
writer.Write(Sig2);
writer.Write(Sig3);
writer.Write(Padding);
// The absolute smallest an archive with a header and one
// valid file entry can be is 37 bytes.
if (sizeLimit.HasValue && sizeLimit < 37)
{
throw new ArgumentOutOfRangeException("sizeLimit", sizeLimit,
"The sizeLimit argument must at least be greater than 36.");
}
// Data
for (int i = startIndex; i < files.Count; ++i)
{
var file = files[i];
writer.Offset = (uint)fileStream.Position;
if (sizeLimit.HasValue && i > startIndex && fileStream.Position +
MinFileEntrySize + file.Data.Length > sizeLimit)
{
return(i);
}
writer.AddOffset("dataEndOffset");
writer.Write((uint)file.Data.LongLength);
writer.AddOffset("dataStartOffset");
writer.WriteNulls(8); // TODO: Figure out what unknown1 and unknown2 are.
writer.WriteNullTerminatedString(file.Name);
writer.FixPadding(Padding);
writer.FillInOffset("dataStartOffset", false);
writer.Write(file.Data);
writer.FillInOffset("dataEndOffset", false);
}
return(-1);
}
public override void Save(ExtendedBinaryWriter writer)
{
ManualCount = 0;
var strings = new List <string>();
writer.WriteSignature("STSC");
writer.AddOffset("EntryPosition");
writer.Write(Version);
switch (Version)
{
case 4: // Date A Live: Twin Edition Rio Reincarnation (PSV)
writer.Write((ushort)ScriptID);
break;
case 7: // Date A Live: Rio Reincarnation (PC)
writer.WriteSignature(ScriptName);
writer.WriteNulls((uint)(0x20 - ScriptName.Length)); // Pad Script Name
writer.Write(0x000607E3);
writer.Write((short)0x06);
writer.Write((short)0x0A);
writer.Write((short)0x06);
writer.Write((short)0x17);
writer.Write(ScriptID);
break;
}
writer.FillInOffset("EntryPosition");
foreach (var instruction in Instructions)
{
writer.Write((byte)STSCInstructions.DALRRInstructions.FindIndex(t => t?.Name == instruction.Name));
instruction.Write(writer, ref ManualCount, strings);
}
// Write String Table
for (int i = 0; i < strings.Count; ++i)
{
writer.FillInOffset($"Strings_{i}");
writer.WriteNullTerminatedString(strings[i]);
}
writer.FixPadding(0x04);
WriteStage1(writer);
WriteStage2(writer);
WriteStage3(writer);
WriteStage4(writer);
WriteStage5(writer);
WriteStage6(writer);
WriteStage7(writer);
WriteStage8(writer);
WriteStage9(writer);
// Older versions may not include art books and drama CDs
if (Version == 7)
{
WriteStage10(writer);
WriteStage11(writer);
}
writer.FixPadding(0x10);
}
/// <summary>
/// CGs
/// </summary>
public void WriteStage2(ExtendedBinaryWriter writer)
{
writer.FillInOffset("Manual_Ptr_1l", true, false);
int i = 0;
foreach (var entry in _CGs)
{
writer.AddOffset($"CGName{i}");
writer.Write(entry.ID);
writer.Write(entry.CGID);
writer.Write(entry.CGID2);
writer.Write(entry.Unknown5);
writer.Write(entry.Unknown6);
writer.Write(entry.TextureWidth);
writer.Write(entry.TextureHeight);
writer.Write(entry.Unknown7);
writer.Write(entry.Unknown81);
writer.Write(entry.Unknown82);
writer.Write(entry.Unknown83);
writer.Write(entry.Page);
writer.Write(entry.FrameCount);
writer.Write((byte)entry.GameID);
writer.Write(entry.Unknown93);
writer.Write(entry.Unknown94);
writer.Write(entry.Unknown10);
writer.Write(entry.Unknown11);
writer.Write(entry.Unknown12);
writer.Write(entry.Unknown13);
writer.Write(entry.Unknown14);
writer.Write(entry.Unknown15);
writer.Write(entry.Unknown16);
writer.Write(entry.Unknown17);
writer.Write(entry.Unknown18);
writer.Write(entry.Unknown19);
writer.Write(entry.Unknown20);
writer.Write(entry.Unknown21);
writer.Write(entry.Unknown22);
writer.Write(entry.Unknown23);
writer.Write(entry.Unknown24);
writer.Write(entry.Unknown25);
writer.Write(entry.Unknown26);
writer.Write(entry.Unknown27);
++i;
}
writer.FillInOffset("Manual_Ptr_1h", true, false);
i = 0;
foreach (var entry in _CGs)
{
writer.FillInOffset($"CGName{i}");
writer.WriteNullTerminatedString(entry.Name);
++i;
}
writer.FixPadding(0x4);
}
public override void Save(ExtendedBinaryWriter writer)
{
var strings = new List <string>();
writer.WriteSignature("STSC");
writer.AddOffset("EntryPosition");
writer.Write(Version);
switch (Version)
{
case 4: // Date A Live: Twin Edition Rio Reincarnation (PSV)
writer.Write((ushort)ScriptID);
break;
case 7: // Date A Live: Rio Reincarnation (PC)
writer.WriteSignature(ScriptName);
writer.WriteNulls((uint)(0x20 - ScriptName.Length)); // Pad Script Name
writer.Write(0x000507E3);
writer.Write((short)0x09);
writer.Write((short)0x0D);
writer.Write((short)0x19);
writer.Write((short)0x0D);
writer.Write(ScriptID);
break;
}
writer.FillInOffset("EntryPosition");
foreach (var instruction in Instructions)
{
writer.Write((byte)STSCInstructions.DALRRInstructions.FindIndex(t => t?.Name == instruction.Name));
instruction.Write(writer, ref ManualCount, strings);
}
// Write String Table
Dictionary <string, uint> writtenStrings = new Dictionary <string, uint>();
for (int i = 0; i < strings.Count; ++i)
{
if (!writer.HasOffset($"Strings_{i}"))
{
continue;
}
if (writtenStrings.ContainsKey(strings[i]))
{
writer.FillInOffset($"Strings_{i}", writtenStrings[strings[i]]);
continue;
}
writer.FillInOffset($"Strings_{i}");
writtenStrings.Add(strings[i], (uint)writer.BaseStream.Position);
writer.WriteNullTerminatedString(strings[i]);
}
writer.FixPadding(0x10);
}
/// <summary>
/// System Text
/// </summary>
public void WriteStage1(ExtendedBinaryWriter writer)
{
writer.FillInOffset("Manual_Ptr_0l", true, false);
for (int i = 0; i < _systemText.Count; ++i)
{
writer.AddOffset($"Stage1_{i}");
}
writer.FillInOffset("Manual_Ptr_0h", true, false);
for (int i = 0; i < _systemText.Count; ++i)
{
writer.FillInOffset($"Stage1_{i}");
writer.WriteNullTerminatedString(_systemText.ElementAt(i));
}
writer.FixPadding(0x4);
}
/// <summary>
/// Characters
/// </summary>
public void WriteStage5(ExtendedBinaryWriter writer)
{
writer.FillInOffset("Manual_Ptr_4l", true, false);
int i = 0;
foreach (var entry in _characters)
{
writer.AddOffset($"Name{i}");
writer.Write(entry.ID);
++i;
}
writer.FillInOffset("Manual_Ptr_4h", true, false);
i = 0;
foreach (var entry in _characters)
{
writer.FillInOffset($"Name{i}");
writer.WriteNullTerminatedString(entry.FriendlyName);
++i;
}
writer.FixPadding(0x4);
}
protected void SaveHeroesArchive(ExtendedBinaryWriter writer)
{
var files = GetFiles(false);
writer.Write(0u); // Padding
writer.AddOffset("fileSize"); // File Size (will be overwritten later)
writer.Write(Magic); // HeroesMagic
writer.Write(1u); // Unknown1
writer.AddOffset("dataOffset"); // Data Offset
writer.Write(Magic); // HeroesMagic2
writer.WriteNulls(StringLength * 2);
// DATA
if (files.Count > FileEntryCount)
{
Console.WriteLine("{0} {1} files! The remaining {2} will be skipped.",
"WARNING: The Heroes archive format only allows for", FileEntryCount,
files.Count - FileEntryCount);
}
// File Names
char[] stringBuffer;
int len = 0;
for (int i = 0; i < FileEntryCount; ++i)
{
// Write the remainding slots and break if there are less than 256 files.
if (i >= files.Count)
{
writer.WriteNulls((uint)((FileEntryCount - i - 1) * StringLength));
break;
}
// Print out a warning if the file name is larger then 64 characters.
var file = files[i];
if (file.Name.Length > StringLength)
{
Console.WriteLine("WARNING: The file name \"{0}\" is larger then {1}! {2}",
file.Name, StringLength, "Part of the filename may get cut off.");
}
// Write FileName with length capped to StringLength.
len = (file.Name.Length > StringLength)
? StringLength : file.Name.Length;
stringBuffer = file.Name.ToCharArray(0, len);
writer.Write(stringBuffer);
if ((StringLength - len) > 0)
{
writer.WriteNulls(StringLength - (uint)len);
}
}
// File Entries
writer.FillInOffset("dataOffset", (FileEntryCount + 1) * StringLength, true);
for (int i = 0; i < files.Count; ++i)
{
var file = files[i];
writer.Write(i + 2); // File Name Index
writer.Write(file.Data.Length); // Data Length
writer.Write(Magic); // HeroesMagic3
// TODO: Compress Data
writer.Write(file.Data); // Compressed Data
}
writer.FillInOffset("fileSize",
(uint)writer.BaseStream.Position - 0xC, true);
}
public override void Save(ExtendedBinaryWriter writer)
{
// Loads all files into memory if not already
// This is needed to ensure the reading stream is closed
Preload();
// ZLIB Compression
Stream mainStream = null;
if (Compress)
{
mainStream = writer.StartDeflateEncapsulation();
}
// Filename Section
// Address of the Filename section
long sectionPosition = writer.BaseStream.Position;
writer.WriteDALSignature("Filename", UseSmallSig);
writer.AddOffset("SectionSize");
// Allocates space for all the file name pointers
foreach (var entry in FileEntries)
{
writer.AddOffset(entry.FileName);
}
// Fills in all the file names
foreach (var entry in FileEntries)
{
// Fill in the address and write the file name (including paths)
writer.FillInOffset(entry.FileName, (uint)(writer.BaseStream.Position - (UseSmallSig ? 0xC : 0x18)));
writer.WriteNullTerminatedString(entry.FileName);
}
// Fills in the size of the Filename section
writer.FillInOffset("SectionSize");
// Realigns the writer
writer.FixPadding(UseSmallSig ? 0x04u : 0x08u);
// Pack Section
// Address to the Pack section
sectionPosition = writer.BaseStream.Position;
writer.WriteDALSignature("Pack", UseSmallSig);
writer.AddOffset("SectionSize");
writer.Write(FileEntries.Count);
// Writes file data entries
for (int i = 0; i < FileEntries.Count; ++i)
{
// Allocates 4 bytes for the absolute address of the contents of the file
writer.AddOffset($"DataPtr{i}");
// Writes the length of the file
writer.Write(FileEntries[i].Data.Length);
}
// Fills in the size of the Pack section
writer.FillInOffset("SectionSize", (uint)(writer.BaseStream.Position - (UseSmallSig ? 0xC : 0x18)));
// Realigns the writer
writer.FixPadding(UseSmallSig ? 0x04u : 0x08u);
// Data
for (int i = 0; i < FileEntries.Count; ++i)
{
writer.FillInOffset($"DataPtr{i}");
writer.Write(FileEntries[i].Data);
// Realigns the writer
writer.FixPadding(UseSmallSig ? 0x04u : 0x08u);
}
// Finalise ZLIB Compression
if (Compress)
{
writer.EndDeflateEncapsulation(mainStream);
}
}
