private byte[] GetOld()
{
using (MemoryStream MS = new MemoryStream())
{
BinaryWriter writer = IOTools.OpenWriteFile(MS, IsLittleEndian);
foreach (var a in SubFiles)
{
byte[] name = new byte[0x100 - 4];
Encoding.ASCII.GetBytes(a.Name, 0, a.Name.Length, name, 0);
writer.Write(name);
byte[] data = a.GameData.GetData();
int size = a.GameData.GetSize();
if (data.Length != size)
{
}
writer.Write(size);
writer.Write(data);
writer.Write(new byte[IOTools.Alignment(MS.Position, 0x40)]);
}
writer.Write(new byte[0x100]);
return(MS.ToArray());
}
}
public int GetSize()
{
int returned = 0x10;
returned += Entries.Count * 4;
returned += IOTools.Alignment(returned, 0x10);
int entryoffset = 0;
if (type == 0)
{
entryoffset = 0x10;
}
else if (type == 1)
{
entryoffset = 4;
}
foreach (var a in Entries)
{
returned += entryoffset;
returned += a.Sum(x => x.Length);
returned += IOTools.Alignment(returned, 0x10);
}
return(returned);
}
public byte[] GetData()
{
byte[] returned;
using (MemoryStream MS = new MemoryStream())
using (BinaryWriter writer = IOTools.OpenWriteFile(MS, IsLittleEndian))
{
writer.Write(HeaderNumber);
writer.Write(MagicNumber);
writer.Write(GetSize());
writer.Write((uint)((type << 16) + Entries.Count));
writer.BaseStream.Position += Entries.Count * 4;
writer.BaseStream.Position += IOTools.Alignment(writer.BaseStream.Position, 0x10);
if (type == 0)
{
GetT0(writer);
}
else if (type == 1)
{
GetT1(writer);
}
returned = MS.ToArray();
}
return(returned);
}
public int GetSize()
{
int returned = 0;
if (Old)
{
foreach (var a in SubFiles)
{
returned += 0x100;
returned += a.GameData.GetSize();
returned += IOTools.Alignment(returned, 0x40);
}
returned += 0x100;
}
else
{
returned += 4;
foreach (var a in SubFiles)
{
returned += 0x20 + 4;
int size = a.GameData.GetSize();
int align = IOTools.Alignment(size, 0x20);
returned += size + align;
}
}
return(returned);
}
private void WriteUnnamed(Dictionary <int, byte[][]> data)
{
var unnamedFiles = SubFiles.FindAll(x => !MainFileList.Contains((int)(x.Tag as object[])[0]));
foreach (var a in unnamedFiles)
{
byte[][] type = new byte[1][];
var temp = a.GameData.GetData();
int align = IOTools.Alignment(temp.Length, 16);
byte[] tempType = null;
if (align == 0)
{
tempType = temp;
}
else
{
tempType = new byte[temp.Length + align];
Buffer.BlockCopy(temp, 0, tempType, 0, temp.Length);
}
type[0] = tempType;
data.Add((int)(a.Tag as object[])[0], type);
}
}
private void Read(StreamPart streamFile, string name)
{
GetType(streamFile);
int index = 0;
streamFile.Stream.Position = streamFile.Position;
using (BinaryReader reader = IOTools.OpenReadFile(streamFile.Stream, IsLittleEndian))
do
{
int Size = reader.ReadInt32();
if (streamFile.Position + streamFile.Size < Size + streamFile.Stream.Position)
{
throw new Exception("TBL error");
}
byte[] tempdata = reader.ReadBytes(Size);
FormatEnum fileType = GameFormatHelper.GetFormat(tempdata);
string ext = Path.GetExtension(name);
string tempName = name.Substring(0, name.Length - ext.Length) + "(" + index++.ToString().PadLeft(2, '0') + ")";
if (fileType == FormatEnum.Unknown)
{
tempName += ".DAT";
}
else
{
tempName += "." + fileType.ToString();
}
SubFiles.Add(GameFormatHelper.OpenFile(tempName, tempdata, fileType == FormatEnum.Unknown ? FormatEnum.DAT : fileType));
reader.BaseStream.Position += IOTools.Alignment(reader.BaseStream.Position - streamFile.Position, 16);
} while (streamFile.Stream.Position < streamFile.Position + streamFile.Size);
}
public byte[] GetData()
{
using (MemoryStream MS = new MemoryStream())
using (BinaryWriter writer = IOTools.OpenWriteFile(MS, IsLittleEndian))
{
writer.BaseStream.Position = (SubFiles.Count + 1) * 12;
List <int[]> Entry = new List <int[]>();
for (int i = 0; i < SubFiles.Count; i++)
{
Entry.Add(new int[] { FlagList[i], (int)writer.BaseStream.Position, SubFiles[i].GameData.GetSize() });
writer.Write(SubFiles[i].GameData.GetData());
writer.Write(new byte[IOTools.Alignment(writer.BaseStream.Position, 16)]);
}
writer.BaseStream.Position = 0;
foreach (var a in Entry)
{
writer.WriteInt32Array(a);
}
return(MS.ToArray());
}
}
private void CreateCache(string path)
{
using (BinaryWriter writer = new BinaryWriter(File.Create(path)))
{
writer.Write(Width);
writer.Write(Height);
writer.Write(Palette.Length);
writer.Write(DataList.Count);
writer.Write(CutList.Count);
writer.BaseStream.Position += IOTools.Alignment(writer.BaseStream.Position, 0x10);
foreach (var a in Palette)
{
writer.Write(a.R);
writer.Write(a.G);
writer.Write(a.B);
writer.Write(a.A);
}
writer.BaseStream.Position += IOTools.Alignment(writer.BaseStream.Position, 0x10);
foreach (var a in DataList)
{
writer.Write(a.Value);
}
writer.BaseStream.Position += IOTools.Alignment(writer.BaseStream.Position, 0x10);
foreach (var a in CutList)
{
writer.Write(a.Value.Left);
writer.Write(a.Value.Right);
}
writer.BaseStream.Position += IOTools.Alignment(writer.BaseStream.Position, 0x10);
}
}
private void OpenPTP0(BinaryReader reader)
{
reader.ReadInt32();
int MSGPos = reader.ReadInt32();
int MSGCount = reader.ReadInt32();
int NamesPos = reader.ReadInt32();
int NamesCount = reader.ReadInt32();
reader.BaseStream.Position = NamesPos;
for (int i = 0; i < NamesCount; i++)
{
int size = reader.ReadInt32();
byte[] OldName = reader.ReadBytes(size);
reader.BaseStream.Position += IOTools.Alignment(reader.BaseStream.Position, 4);
size = reader.ReadInt32();
string NewName = Encoding.UTF8.GetString(reader.ReadBytes(size));
reader.BaseStream.Position += IOTools.Alignment(reader.BaseStream.Position, 4);
Names.Add(new PTPName(i, OldName, NewName));
}
reader.BaseStream.Position = MSGPos;
for (int i = 0; i < MSGCount; i++)
{
int type = reader.ReadInt32();
byte[] buffer = reader.ReadBytes(24);
string Name = Encoding.ASCII.GetString(buffer.Where(x => x != 0).ToArray());
int StringCount = reader.ReadInt16();
int CharacterIndex = reader.ReadInt16();
PTPMSG mSG = new PTPMSG(i, type, Name, CharacterIndex);
for (int k = 0; k < StringCount; k++)
{
int size = reader.ReadInt32();
byte[] Prefix = reader.ReadBytes(size);
reader.BaseStream.Position += IOTools.Alignment(reader.BaseStream.Position, 4);
size = reader.ReadInt32();
byte[] OldString = reader.ReadBytes(size);
reader.BaseStream.Position += IOTools.Alignment(reader.BaseStream.Position, 4);
size = reader.ReadInt32();
byte[] Postfix = reader.ReadBytes(size);
reader.BaseStream.Position += IOTools.Alignment(reader.BaseStream.Position, 4);
size = reader.ReadInt32();
string NewString = Encoding.UTF8.GetString(reader.ReadBytes(size));
reader.BaseStream.Position += IOTools.Alignment(reader.BaseStream.Position, 16);
mSG.Strings.Add(new PTPMSGstr(k, NewString, Prefix, OldString, Postfix)
{
CharacterIndex = CharacterIndex
});
}
Msg.Add(mSG);
}
}
public void Write(BinaryWriter writer, int offset, List <int> pointers)
{
int size = 28;
writer.WriteString(Name, Encoding.ASCII, 24);
if (Type == 0)
{
writer.Write((ushort)MsgStrings.Length);
if (NameIndex == -1)
{
writer.Write((ushort)0xFFFF);
}
else
{
writer.Write((ushort)NameIndex);
}
}
else if (Type == 1)
{
writer.Write((ushort)0);
writer.Write((ushort)MsgStrings.Length);
writer.Write(SEL_UNKNOWN);
size += 4;
}
else
{
throw new Exception("BMD Write Error: Unknown type");
}
if (MsgStrings.Length > 0)
{
size += 4 + 4 * MsgStrings.Length;
int sum = 0;
foreach (var a in MsgStrings)
{
pointers.Add((int)writer.BaseStream.Position);
writer.Write(offset + size + sum);
sum += a.Length;
}
writer.Write(sum);
foreach (var a in MsgStrings)
{
writer.Write(a);
}
writer.Write(new byte[IOTools.Alignment(size + sum, 4)]);
}
}
public int Get(BinaryWriter writer)
{
writer.Write(new byte[IOTools.Alignment(writer.BaseStream.Length, 16)]);
long returned = writer.BaseStream.Position;
foreach (var a in List)
{
writer.Write(a);
}
return(Convert.ToInt32(returned));
}
private void UpdateOffsets(List <int> list, int start)
{
list[0] = start;
for (int i = 1; i < SubFiles.Count; i++)
{
start += SubFiles[i - 1].GameData.GetSize();
int temp = IOTools.Alignment(start, 16);
start += temp == 0 ? 16 : temp;
list[i] = start;
}
}
public byte[] GetData()
{
using (MemoryStream MS = new MemoryStream())
using (BinaryWriter writer = IOTools.OpenWriteFile(MS, IsLittleEndian))
{
foreach (var element in SubFiles)
{
writer.Write(element.GameData.GetSize());
writer.Write(element.GameData.GetData());
writer.Write(new byte[IOTools.Alignment(writer.BaseStream.Position, 16)]);
}
return(MS.ToArray());
}
}
public int GetSize()
{
int returned = 28;
if (Type == 1)
{
returned += 4;
}
if (MsgStrings.Length > 0)
{
returned += 4 + 4 * MsgStrings.Length;
}
returned += MsgStrings.Sum(x => x.Length);
returned += IOTools.Alignment(returned, 4);
return(returned);
}
public byte[] GetData()
{
byte[] returned;
using (MemoryStream MS = new MemoryStream())
{
BinaryWriter writer = IOTools.OpenWriteFile(MS, IsLittleEndian);
Header.Get(writer);
foreach (var a in TextureOffsetList)
{
writer.Write((int)0);
writer.Write(a);
}
foreach (var a in KeyOffsetList)
{
writer.Write((int)0);
writer.Write(a);
}
KeyList.Get(writer);
int temp = IOTools.Alignment(writer.BaseStream.Position, 16);
writer.Write(new byte[temp == 0 ? 16 : temp]);
UpdateOffsets(TextureOffsetList, (int)writer.BaseStream.Position);
writer.Write(SubFiles[0].GameData.GetData());
for (int i = 1; i < SubFiles.Count; i++)
{
int temp2 = IOTools.Alignment(writer.BaseStream.Length, 16);
writer.Write(new byte[temp2 == 0 ? 16 : temp2]);
writer.Write(SubFiles[i].GameData.GetData());
}
writer.BaseStream.Position = Header.Size;
foreach (var a in TextureOffsetList)
{
writer.Write((int)0);
writer.Write(a);
}
returned = MS.ToArray();
}
return(returned);
}
private void GetType(StreamPart streamFile)
{
try
{
streamFile.Stream.Position = streamFile.Position;
using (BinaryReader reader = IOTools.OpenReadFile(streamFile.Stream, true))
do
{
int Size = reader.ReadInt32();
if (streamFile.Position + streamFile.Size < Size + streamFile.Stream.Position)
{
throw new Exception("TBL error");
}
reader.BaseStream.Position += Size;
reader.BaseStream.Position += IOTools.Alignment(reader.BaseStream.Position - streamFile.Position, 16);
} while (streamFile.Stream.Position < streamFile.Position + streamFile.Size);
IsLittleEndian = true;
}
catch
{
try
{
streamFile.Stream.Position = streamFile.Position;
using (BinaryReader reader = IOTools.OpenReadFile(streamFile.Stream, false))
do
{
int Size = reader.ReadInt32();
if (streamFile.Position + streamFile.Size < Size + streamFile.Stream.Position)
{
throw new Exception("TBL error");
}
reader.BaseStream.Position += Size;
reader.BaseStream.Position += IOTools.Alignment(reader.BaseStream.Position - streamFile.Position, 16);
} while (streamFile.Stream.Position < streamFile.Position + streamFile.Size);
IsLittleEndian = false;
}
catch
{
throw new Exception("TBL error");
}
}
}
private void GetT1(BinaryWriter writer)
{
List <int> newPos = new List <int>();
foreach (var entry in Entries)
{
newPos.Add((int)writer.BaseStream.Position);
writer.Write((byte)entry.Sum(x => x.Length));
writer.Write((byte)entry.Length);
writer.BaseStream.Position += 2;
foreach (var part in entry)
{
writer.Write(part);
}
writer.BaseStream.Position += IOTools.Alignment(writer.BaseStream.Position, 0x10);
}
writer.Write(new byte[IOTools.Alignment(writer.BaseStream.Position, 0x10)]);
writer.BaseStream.Position = 0x10;
newPos.ForEach(x => writer.Write(x));
}
private byte[] GetNew()
{
using (MemoryStream MS = new MemoryStream())
{
BinaryWriter writer = IOTools.OpenWriteFile(MS, IsLittleEndian);
writer.Write((int)SubFiles.Count);
foreach (var a in SubFiles)
{
writer.Write(Encoding.ASCII.GetBytes(a.Name));
writer.Write(new byte[IOTools.Alignment(a.Name.Length, 0x20)]);
int size = a.GameData.GetSize();
int align = IOTools.Alignment(size, 0x20);
writer.Write(size + align);
writer.Write(a.GameData.GetData());
writer.Write(new byte[align]);
}
return(MS.ToArray());
}
}
private void OpenCache(string path)
{
using (BinaryReader reader = new BinaryReader(File.OpenRead(path)))
{
Width = reader.ReadInt32();
Height = reader.ReadInt32();
int colorcount = reader.ReadInt32();
int datacount = reader.ReadInt32();
int cutcount = reader.ReadInt32();
if (colorcount == 16)
{
PixelFormat = PixelFormats.Indexed4;
}
else if (colorcount == 256)
{
PixelFormat = PixelFormats.Indexed8;
}
else
{
}
reader.BaseStream.Position += IOTools.Alignment(reader.BaseStream.Position, 0x10);
Palette = ReadPalette(reader, colorcount).ToArray();
int glyphsize = (PixelFormat.BitsPerPixel * Width * Height) / 8;
reader.BaseStream.Position += IOTools.Alignment(reader.BaseStream.Position, 0x10);
for (int i = 32; i < 32 + datacount; i++)
{
DataList.Add(i, reader.ReadBytes(glyphsize));
}
reader.BaseStream.Position += IOTools.Alignment(reader.BaseStream.Position, 0x10);
for (int i = 32; i < 32 + cutcount; i++)
{
CutList.Add(i, new VerticalCut(reader.ReadBytes(2)));
}
}
}
public int GetSize()
{
int returned = 0;
returned += Header.Size;
returned += TextureOffsetList.Count * 8;
returned += KeyOffsetList.Count * 8;
returned += KeyList.Size;
int temp = IOTools.Alignment(returned, 16);
returned += temp == 0 ? 16 : temp;
returned += (SubFiles[0].GameData as IGameData).GetSize();
for (int i = 1; i < SubFiles.Count; i++)
{
temp = IOTools.Alignment(returned, 16);
returned += temp == 0 ? 16 : temp;
returned += SubFiles[i].GameData.GetSize();
}
return(returned);
}
private void OpenOld(byte[] data)
{
IsLittleEndian = true;
if (data.Length < 0x100)
{
throw new System.Exception("BIN: data length unacceptable");
}
using (BinaryReader reader = IOTools.OpenReadFile(new MemoryStream(data), IsLittleEndian, false))
while (reader.BaseStream.Position < reader.BaseStream.Length - 0x100)
{
string Name = Encoding.ASCII.GetString(reader.ReadBytes(0x100 - 4)).Trim('\0');
int Size = reader.ReadInt32();
byte[] Data = reader.ReadBytes(Size);
reader.BaseStream.Position += IOTools.Alignment(reader.BaseStream.Position, 0x40);
GameFile objectFile = GameFormatHelper.OpenFile(Name, Data, GameFormatHelper.GetFormat(Name));
if (objectFile == null)
{
objectFile = GameFormatHelper.OpenFile(Name, Data, FormatEnum.DAT);
}
SubFiles.Add(objectFile);
}
}
private bool Open(Stream stream)
{
try
{
BinaryReader reader = new BinaryReader(stream);
stream.Position = 0;
if (Encoding.ASCII.GetString(reader.ReadBytes(4)) == "PTP0")
{
Names.Clear();
Msg.Clear();
int MSGPos = reader.ReadInt32();
int MSGCount = reader.ReadInt32();
int NamesPos = reader.ReadInt32();
int NamesCount = reader.ReadInt32();
stream.Position = NamesPos;
for (int i = 0; i < NamesCount; i++)
{
int size = reader.ReadInt32();
byte[] OldName = reader.ReadBytes(size);
stream.Position += IOTools.Alignment(stream.Position, 4);
size = reader.ReadInt32();
string NewName = Encoding.UTF8.GetString(reader.ReadBytes(size));
stream.Position += IOTools.Alignment(stream.Position, 4);
Names.Add(new PTPName(i, OldName, NewName));
}
stream.Position = MSGPos;
for (int i = 0; i < MSGCount; i++)
{
int type = reader.ReadInt32();
byte[] buffer = reader.ReadBytes(24);
string Name = Encoding.ASCII.GetString(buffer.Where(x => x != 0).ToArray());
int StringCount = reader.ReadInt16();
int CharacterIndex = reader.ReadInt16();
PTPMSG mSG = new PTPMSG(i, type, Name, CharacterIndex);
for (int k = 0; k < StringCount; k++)
{
int size = reader.ReadInt32();
byte[] Prefix = reader.ReadBytes(size);
stream.Position += IOTools.Alignment(stream.Position, 4);
size = reader.ReadInt32();
byte[] OldString = reader.ReadBytes(size);
stream.Position += IOTools.Alignment(stream.Position, 4);
size = reader.ReadInt32();
byte[] Postfix = reader.ReadBytes(size);
stream.Position += IOTools.Alignment(stream.Position, 4);
size = reader.ReadInt32();
string NewString = Encoding.UTF8.GetString(reader.ReadBytes(size));
stream.Position += IOTools.Alignment(stream.Position, 16);
mSG.Strings.Add(new PTPMSGstr(k, NewString, Prefix, OldString, Postfix)
{
CharacterIndex = CharacterIndex
});
}
Msg.Add(mSG);
}
return(true);
}
return(false);
}
catch (Exception e)
{
Names.Clear();
Msg.Clear();
// Logging.Write("PTPfactory", e.ToString());
return(false);
}
}
private void WriteNamed(Dictionary <int, byte[][]> data)
{
void WriteSingleFile(TypeMap typeMap)
{
var TYPE = SubFiles.Find(x => (int)(x.Tag as object[])[0] == (int)typeMap);
if (TYPE != null)
{
byte[][] type = new byte[1][];
var temp = TYPE.GameData.GetData();
int align = IOTools.Alignment(temp.Length, 16);
byte[] tempType = null;
if (align == 0)
{
tempType = temp;
}
else
{
tempType = new byte[temp.Length + align];
Buffer.BlockCopy(temp, 0, tempType, 0, temp.Length);
}
type[0] = tempType;
data.Add((int)typeMap, type);
}
}
// Write T3
WriteSingleFile(TypeMap.T3);
// Write RMD
var RMD = SubFiles.FindAll(x => (int)(x.Tag as object[])[0] == (int)TypeMap.RMD);
if (RMD.Count != 0)
{
byte[][] rmdHeader = new byte[RMD.Count][];
byte[][] rmd = new byte[1][];
int offset = 0;
using (MemoryStream MS = new MemoryStream())
{
for (int i = 0; i < RMD.Count; i++)
{
byte[] temp = RMD[i].GameData.GetData();
byte[] tempRMD = new byte[temp.Length + IOTools.Alignment(temp.Length, 16)];
Buffer.BlockCopy(temp, 0, tempRMD, 0, temp.Length);
MS.Write(tempRMD, 0, tempRMD.Length);
var tempHeader = (RMD[i].Tag as object[])[1] as int[];
tempHeader[4] = offset;
tempHeader[5] = temp.Length;
using (MemoryStream headerMS = new MemoryStream())
using (BinaryWriter writer = IOTools.OpenWriteFile(headerMS, IsLittleEndian))
{
writer.WriteInt32Array(tempHeader);
rmdHeader[i] = headerMS.ToArray();
}
offset += tempRMD.Length;
}
rmd[0] = MS.ToArray();
}
data.Add((int)TypeMap.RMD, rmd);
data.Add((int)TypeMap.RMDHead, rmdHeader);
}
// Write BMD
WriteSingleFile(TypeMap.BMD);
// Write EPL
var EPL = SubFiles.FindAll(x => (int)(x.Tag as object[])[0] == (int)TypeMap.EPL);
if (EPL.Count != 0)
{
byte[][] eplHeader = new byte[EPL.Count][];
byte[][] epl = new byte[1][];
int offset = 0;
using (MemoryStream MS = new MemoryStream())
{
for (int i = 0; i < EPL.Count; i++)
{
byte[] temp = EPL[i].GameData.GetData();
byte[] tempEPL = new byte[temp.Length + IOTools.Alignment(temp.Length, 16)];
Buffer.BlockCopy(temp, 0, tempEPL, 0, temp.Length);
MS.Write(tempEPL, 0, tempEPL.Length);
var tempHeader = (EPL[i].Tag as object[])[1] as int[];
tempHeader[1] = offset;
using (MemoryStream headerMS = new MemoryStream())
using (BinaryWriter writer = IOTools.OpenWriteFile(headerMS, IsLittleEndian))
{
writer.WriteInt32Array(tempHeader);
eplHeader[i] = headerMS.ToArray();
}
offset += tempEPL.Length;
}
epl[0] = MS.ToArray();
}
data.Add((int)TypeMap.EPL, epl);
data.Add((int)TypeMap.EPLHead, eplHeader);
}
// Write TMX
var TMX = SubFiles.FindAll(x => (int)(x.Tag as object[])[0] == (int)TypeMap.TMX);
if (TMX.Count != 0)
{
byte[][] tmxHeader = new byte[TMX.Count][];
byte[][] tmx = new byte[1][];
int offset = 0;
using (MemoryStream MS = new MemoryStream())
{
for (int i = 0; i < TMX.Count; i++)
{
byte[] temp = TMX[i].GameData.GetData();
byte[] tempTMX = new byte[temp.Length + IOTools.Alignment(temp.Length, 16)];
Buffer.BlockCopy(temp, 0, tempTMX, 0, temp.Length);
MS.Write(tempTMX, 0, tempTMX.Length);
var tempHeader = (TMX[i].Tag as object[])[1] as int[];
tempHeader[1] = offset;
using (MemoryStream headerMS = new MemoryStream())
using (BinaryWriter writer = IOTools.OpenWriteFile(headerMS, IsLittleEndian))
{
writer.WriteInt32Array(tempHeader);
tmxHeader[i] = headerMS.ToArray();
}
offset += tempTMX.Length;
}
tmx[0] = MS.ToArray();
}
data.Add((int)TypeMap.TMX, tmx);
data.Add((int)TypeMap.TMXHead, tmxHeader);
}
// Write CTable
WriteSingleFile(TypeMap.CTable);
}
public byte[] GetData()
{
using (MemoryStream MS = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(MS))
{
byte[] buffer;
writer.Write(Encoding.ASCII.GetBytes("PTP0"));
long MSGLinkPos = MS.Position;
writer.Write(0);
writer.Write(Msg.Count);
long NamesLinkPos = MS.Position;
writer.Write(0);
writer.Write(Names.Count);
writer.Write(new byte[IOTools.Alignment(MS.Position, 0x10)]);
long MSGPos = MS.Position;
foreach (var a in Msg)
{
writer.Write(a.Type);
buffer = new byte[24];
Encoding.ASCII.GetBytes(a.Name, 0, a.Name.Length, buffer, 0);
writer.Write(buffer);
writer.Write((ushort)a.Strings.Count);
writer.Write((ushort)a.CharacterIndex);
foreach (var b in a.Strings)
{
buffer = b.Prefix.GetByteArray();
writer.Write(buffer.Length);
writer.Write(buffer);
writer.Write(new byte[IOTools.Alignment(MS.Position, 4)]);
buffer = b.OldString.GetByteArray();
writer.Write(buffer.Length);
writer.Write(buffer);
writer.Write(new byte[IOTools.Alignment(MS.Position, 4)]);
buffer = b.Postfix.GetByteArray();
writer.Write(buffer.Length);
writer.Write(buffer);
writer.Write(new byte[IOTools.Alignment(MS.Position, 4)]);
buffer = Encoding.UTF8.GetBytes(b.NewString);
writer.Write(buffer.Length);
writer.Write(buffer);
writer.Write(new byte[IOTools.Alignment(MS.Position, 16)]);
}
writer.Write(new byte[IOTools.Alignment(MS.Position, 0x10)]);
}
long NamesPos = MS.Position;
foreach (var a in Names)
{
buffer = a.OldName;
writer.Write(buffer.Length);
writer.Write(buffer);
writer.Write(new byte[IOTools.Alignment(MS.Position, 4)]);
buffer = Encoding.UTF8.GetBytes(a.NewName);
writer.Write(buffer.Length);
writer.Write(buffer);
writer.Write(new byte[IOTools.Alignment(MS.Position, 4)]);
}
MS.Position = MSGLinkPos;
writer.Write((int)MSGPos);
MS.Position = NamesLinkPos;
writer.Write((int)NamesPos);
}
return(MS.ToArray());
}
}
public byte[] GetData()
{
using (MemoryStream MS = new MemoryStream())
using (BinaryWriter writer = IOTools.OpenWriteFile(MS, IsLittleEndian))
{
byte[] buffer;
List <int> LastBlock = new List <int>();
#region Header
buffer = new byte[4] {
7, 0, 0, 0
};
writer.Write(buffer);
writer.Write((int)0x0);
buffer = Encoding.ASCII.GetBytes("MSG1");
writer.Write(BitConverter.ToInt32(buffer, 0));
writer.Write((int)0x0);
writer.Write((int)0x0);
writer.Write((int)0x0);
writer.Write(Msg.Count);
writer.Write((ushort)0);
writer.Write((ushort)0x2);
#endregion
#region MSG Pointer
int MSG_offset = Msg.Count * 8 + 16;
foreach (var MSG in Msg)
{
writer.Write(MSG.Type);
LastBlock.Add((int)MS.Position);
writer.Write(MSG_offset);
MSG_offset += MSG.GetSize();
}
LastBlock.Add((int)MS.Position);
writer.Write(MSG_offset);
writer.Write(Name.Count);
writer.Write((int)0x0);
writer.Write((int)0x0);
#endregion
#region MSG
MSG_offset = Msg.Count * 8 + 16;
foreach (var MSG in Msg)
{
MSG.Write(writer, MSG_offset, LastBlock);
MSG_offset += MSG.GetSize();
}
#endregion
#region Name Pointer
MSG_offset += Name.Count * 4;
foreach (var name in Name)
{
LastBlock.Add((int)MS.Position);
writer.Write(MSG_offset);
if (name.NameBytes.Length == 0)
{
MSG_offset += 2;
}
else
{
MSG_offset += name.NameBytes.Length + 1;
}
}
#endregion
#region Name
foreach (var name in Name)
{
if (name.NameBytes.Length == 0)
{
writer.Write((byte)0x20);
}
else
{
writer.Write(name.NameBytes);
}
writer.Write((byte)0);
}
writer.Write(new byte[IOTools.Alignment(MS.Position, 4)]);
#endregion
#region Pointers
int LastBlockPos = (int)MS.Position;
byte[] ptrDiffSection = CreatePointersDiffSection(LastBlock);
writer.Write(ptrDiffSection);
MS.Position = 0x10;
writer.Write(LastBlockPos);
writer.Write(ptrDiffSection.Length);
MS.Position = 0x4;
writer.Write((int)MS.Length);
#endregion
return(MS.ToArray());
}
}
