654 lines
21 KiB
C#
654 lines
21 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using Toolbox;
|
|
using System.Windows.Forms;
|
|
using Toolbox.Library;
|
|
using FirstPlugin.Forms;
|
|
using Toolbox.Library.IO;
|
|
|
|
namespace FirstPlugin
|
|
{
|
|
public class MSBT : IEditor<MSBTEditor>, IFileFormat, IConvertableTextFormat
|
|
{
|
|
public FileType FileType { get; set; } = FileType.Message;
|
|
|
|
public bool CanSave { get; set; }
|
|
public string[] Description { get; set; } = new string[] { "Message Studio Binary Text" };
|
|
public string[] Extension { get; set; } = new string[] { "*.msbt" };
|
|
public string FileName { get; set; }
|
|
public string FilePath { get; set; }
|
|
public IFileInfo IFileInfo { get; set; }
|
|
|
|
public bool Identify(System.IO.Stream stream)
|
|
{
|
|
using (var reader = new Toolbox.Library.IO.FileReader(stream, true))
|
|
{
|
|
return reader.CheckSignature(8, "MsgStdBn");
|
|
}
|
|
}
|
|
|
|
public Type[] Types
|
|
{
|
|
get
|
|
{
|
|
List<Type> types = new List<Type>();
|
|
return types.ToArray();
|
|
}
|
|
}
|
|
|
|
|
|
#region Text Converter Interface
|
|
public TextFileType TextFileType => TextFileType.Xml;
|
|
public bool CanConvertBack => false;
|
|
|
|
public string ConvertToString() {
|
|
return MSYT.ToYaml(this);
|
|
}
|
|
|
|
public void ConvertFromString(string text)
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
public MSBTEditor OpenForm()
|
|
{
|
|
MSBTEditor editor = new MSBTEditor();
|
|
editor.Text = FileName;
|
|
editor.Dock = DockStyle.Fill;
|
|
return editor;
|
|
}
|
|
|
|
public void FillEditor(UserControl control)
|
|
{
|
|
((MSBTEditor)control).LoadMSBT(this);
|
|
}
|
|
|
|
public Header header;
|
|
|
|
public void Load(System.IO.Stream stream)
|
|
{
|
|
CanSave = false;
|
|
|
|
header = new Header();
|
|
header.Read(new FileReader(stream));
|
|
}
|
|
public void Unload()
|
|
{
|
|
|
|
}
|
|
|
|
public void Save(System.IO.Stream stream)
|
|
{
|
|
header.Write(new FileWriter(stream));
|
|
}
|
|
|
|
public bool HasLabels
|
|
{
|
|
get { return header.Label1.Labels.Count > 0; }
|
|
}
|
|
|
|
public class Header
|
|
{
|
|
public ushort ByteOrderMark;
|
|
public ushort Padding;
|
|
public ushort Unknown;
|
|
public Encoding StringEncoding = Encoding.Unicode;
|
|
|
|
public byte Version;
|
|
public List<MSBTEntry> entries = new List<MSBTEntry>();
|
|
|
|
byte[] Reserved = new byte[10];
|
|
|
|
public LBL1 Label1;
|
|
public NLI1 NLI1;
|
|
public TXT2 Text2;
|
|
|
|
public bool IsBigEndian = false;
|
|
|
|
public void Read(FileReader reader)
|
|
{
|
|
Label1 = new LBL1();
|
|
NLI1 = new NLI1();
|
|
Text2 = new TXT2();
|
|
|
|
reader.ByteOrder = Syroot.BinaryData.ByteOrder.BigEndian;
|
|
reader.ReadSignature(8, "MsgStdBn");
|
|
ByteOrderMark = reader.ReadUInt16();
|
|
reader.CheckByteOrderMark(ByteOrderMark);
|
|
IsBigEndian = reader.IsBigEndian;
|
|
Padding = reader.ReadUInt16();
|
|
byte encoding = reader.ReadByte();
|
|
Version = reader.ReadByte();
|
|
ushort SectionCount = reader.ReadUInt16();
|
|
Unknown = reader.ReadUInt16();
|
|
uint FileSize = reader.ReadUInt32();
|
|
Reserved = reader.ReadBytes(10);
|
|
|
|
|
|
if (encoding == 0x00)
|
|
StringEncoding = Encoding.UTF8;
|
|
else if (reader.IsBigEndian)
|
|
StringEncoding = Encoding.BigEndianUnicode;
|
|
else
|
|
StringEncoding = Encoding.Unicode;
|
|
|
|
for (int i = 0; i < SectionCount; i++)
|
|
{
|
|
if (reader.EndOfStream)
|
|
break;
|
|
|
|
long pos = reader.Position;
|
|
|
|
string Signature = reader.ReadString(4, Encoding.ASCII);
|
|
uint SectionSize = reader.ReadUInt32();
|
|
|
|
Console.WriteLine("Signature " + Signature);
|
|
|
|
switch (Signature)
|
|
{
|
|
case "NLI1":
|
|
NLI1 = new NLI1();
|
|
NLI1.Signature = Signature;
|
|
NLI1.Read(reader, this);
|
|
entries.Add(NLI1);
|
|
break;
|
|
case "TXT2":
|
|
case "TXTW":
|
|
Text2 = new TXT2();
|
|
Text2.Signature = Signature;
|
|
Text2.Read(reader, this);
|
|
entries.Add(Text2);
|
|
break;
|
|
case "LBL1":
|
|
Label1 = new LBL1();
|
|
Label1.Signature = Signature;
|
|
Label1.Read(reader, this);
|
|
entries.Add(Label1);
|
|
break;
|
|
case "ATR1":
|
|
case "ATO1":
|
|
case "TSY1":
|
|
default:
|
|
MSBTEntry entry = new MSBTEntry();
|
|
entry.Signature = Signature;
|
|
entry.Padding = reader.ReadBytes(8);
|
|
entry.Data = reader.ReadBytes((int)SectionSize);
|
|
entries.Add(entry);
|
|
break;
|
|
}
|
|
|
|
reader.SeekBegin(pos + SectionSize + 0x10);
|
|
reader.Align(16);
|
|
}
|
|
|
|
//Setup labels to text properly
|
|
if (Label1 != null && Text2 != null)
|
|
{
|
|
foreach (var label in Label1.Labels)
|
|
label.String = Text2.TextData[(int)label.Index];
|
|
}
|
|
}
|
|
|
|
public void Write(FileWriter writer)
|
|
{
|
|
writer.SetByteOrder(true);
|
|
|
|
writer.WriteSignature("MsgStdBn");
|
|
if (!IsBigEndian)
|
|
writer.Write((ushort)0xFFFE);
|
|
else
|
|
writer.Write((ushort)0xFEFF);
|
|
writer.SetByteOrder(IsBigEndian);
|
|
writer.Write(Padding);
|
|
writer.Write(StringEncoding == Encoding.UTF8 ? (byte)0 : (byte)1);
|
|
writer.Write(Version);
|
|
writer.Write((ushort)entries.Count);
|
|
writer.Write(Unknown);
|
|
|
|
long _ofsFileSize = writer.Position;
|
|
writer.Write(0); //FileSize reserved for later
|
|
writer.Write(Reserved);
|
|
|
|
foreach (var entry in entries)
|
|
WriteSection(writer, this, entry.Signature, entry);
|
|
|
|
//Write file size
|
|
using (writer.TemporarySeek(_ofsFileSize, System.IO.SeekOrigin.Begin))
|
|
{
|
|
writer.Write((uint)writer.BaseStream.Length);
|
|
}
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
var builder = new StringBuilder();
|
|
using (var textWriter = new StringWriter(builder))
|
|
{
|
|
textWriter.Write($"");
|
|
}
|
|
return builder.ToString();
|
|
}
|
|
}
|
|
|
|
public class LabelGroup
|
|
{
|
|
public uint NumberOfLabels;
|
|
public uint Offset;
|
|
}
|
|
|
|
public class LabelEntry : MSBTEntry
|
|
{
|
|
private uint _index;
|
|
|
|
public uint Length;
|
|
public string Name;
|
|
public uint Checksum;
|
|
public StringEntry String;
|
|
|
|
public uint Index
|
|
{
|
|
get { return _index; }
|
|
set { _index = value; }
|
|
}
|
|
|
|
public byte[] Value
|
|
{
|
|
get { return String.Data; }
|
|
set { String.Data = value; }
|
|
}
|
|
}
|
|
|
|
public class StringEntry : MSBTEntry
|
|
{
|
|
private uint _index;
|
|
|
|
public StringEntry(byte[] data) {
|
|
Data = data;
|
|
}
|
|
|
|
public StringEntry(byte[] data, Encoding encoding) {
|
|
Data = data;
|
|
}
|
|
|
|
public StringEntry(string text, Encoding encoding) {
|
|
Data = encoding.GetBytes(text);
|
|
}
|
|
|
|
public uint Index
|
|
{
|
|
get { return _index; }
|
|
set { _index = value; }
|
|
}
|
|
|
|
public string GetTextLabel(bool ShowText, Encoding encoding)
|
|
{
|
|
if (ShowText)
|
|
return $"{_index + 1} {GetText(encoding)}";
|
|
else
|
|
return $"{_index + 1}";
|
|
}
|
|
|
|
public string GetText(Encoding encoding)
|
|
{
|
|
return encoding.GetString(Data);
|
|
}
|
|
|
|
public byte[] ToBytes(Encoding encoding, bool isBigEndian)
|
|
{
|
|
return Data;
|
|
|
|
var mem = new MemoryStream();
|
|
var text = GetText(encoding);
|
|
using (var writer = new FileWriter(mem, encoding)) {
|
|
writer.SetByteOrder(isBigEndian);
|
|
for (int i = 0; i < text.Length; i++)
|
|
{
|
|
var c = text[i];
|
|
writer.Write(c);
|
|
if (c == 0xE)
|
|
{
|
|
writer.Write((short)text[++i]);
|
|
writer.Write((short)text[++i]);
|
|
int count = text[++i];
|
|
writer.Write((short)count);
|
|
for (var j = 0; j < count; j++)
|
|
{
|
|
writer.Write((byte)text[++i]);
|
|
}
|
|
}
|
|
}
|
|
writer.Write('\0');
|
|
}
|
|
return mem.ToArray();
|
|
}
|
|
}
|
|
|
|
public class TXT2 : MSBTEntry
|
|
{
|
|
public uint[] Offsets;
|
|
public List<StringEntry> TextData = new List<StringEntry>();
|
|
public List<StringEntry> OriginalTextData = new List<StringEntry>();
|
|
|
|
public override void Read(FileReader reader, Header header)
|
|
{
|
|
reader.Seek(-4);
|
|
uint sectionSize = reader.ReadUInt32();
|
|
|
|
Padding = reader.ReadBytes(8);
|
|
|
|
long pos = reader.Position;
|
|
EntryCount = reader.ReadUInt32();
|
|
Offsets = reader.ReadUInt32s((int)EntryCount);
|
|
|
|
for (int i = 0; i < EntryCount; i++)
|
|
{
|
|
//Get the start and end position
|
|
uint startPos = Offsets[i] + (uint)pos;
|
|
uint endPos = i + 1 < EntryCount ? (uint)pos + Offsets[i + 1] :
|
|
(uint)pos + sectionSize;
|
|
|
|
reader.SeekBegin(startPos);
|
|
ReadMessageString(reader, header, (uint)i, endPos - startPos);
|
|
}
|
|
}
|
|
|
|
private void ReadMessageString(FileReader reader, Header header, uint index, uint size)
|
|
{
|
|
byte[] textData = reader.ReadBytes((int)size);
|
|
|
|
TextData.Add(new StringEntry(textData, header.StringEncoding) { Index = index, });
|
|
OriginalTextData.Add(new StringEntry(textData, header.StringEncoding) { Index = index, });
|
|
}
|
|
|
|
public override void Write(FileWriter writer, Header header)
|
|
{
|
|
writer.Seek(8);
|
|
|
|
long pos = writer.Position;
|
|
writer.Write(TextData.Count);
|
|
writer.Write(new uint[TextData.Count]);
|
|
|
|
for (int i = 0; i < EntryCount; i++) {
|
|
writer.WriteUint32Offset(pos + 4 + (i * 4), pos);
|
|
writer.Write(TextData[i].ToBytes(header.StringEncoding, header.IsBigEndian));
|
|
}
|
|
}
|
|
|
|
private char[] GetControlCode(FileReader reader)
|
|
{
|
|
//Get char controls
|
|
//Code from https://github.com/Sage-of-Mirrors/WildText/blob/master/WildText/src/MessageManager.cs
|
|
List<char> controlCode = new List<char>();
|
|
controlCode.Add('<');
|
|
|
|
short primaryType = reader.ReadInt16();
|
|
short secondaryType = reader.ReadInt16();
|
|
short dataSize = reader.ReadInt16();
|
|
|
|
switch (primaryType)
|
|
{
|
|
case 0:
|
|
controlCode.AddRange(GetTextModifier(reader, secondaryType));
|
|
break;
|
|
case 1:
|
|
controlCode.AddRange(GetPlayerInput(reader, secondaryType));
|
|
break;
|
|
case 2:
|
|
break;
|
|
case 3:
|
|
controlCode.AddRange(GetAnimationIndex(reader, secondaryType));
|
|
break;
|
|
case 4:
|
|
controlCode.AddRange(GetSoundIndex(reader, secondaryType));
|
|
break;
|
|
case 5:
|
|
controlCode.AddRange(GetPause(reader, secondaryType));
|
|
break;
|
|
default:
|
|
reader.BaseStream.Position += dataSize;
|
|
break;
|
|
}
|
|
|
|
controlCode.Add('>');
|
|
|
|
return controlCode.ToArray();
|
|
}
|
|
|
|
private char[] GetTextModifier(FileReader reader, short secondaryType)
|
|
{
|
|
List<char> result = new List<char>();
|
|
|
|
switch (secondaryType)
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
case 2:
|
|
result.AddRange($"size:{ reader.ReadInt16() }");
|
|
break;
|
|
case 3:
|
|
result.AddRange($"Color:{ reader.ReadInt16() }");
|
|
break;
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
private char[] GetPause(FileReader reader, short secondaryType)
|
|
{
|
|
List<char> result = new List<char>();
|
|
|
|
switch (secondaryType)
|
|
{
|
|
case 0:
|
|
result.AddRange("pause:short");
|
|
break;
|
|
case 1:
|
|
result.AddRange("pause:medium");
|
|
break;
|
|
case 2:
|
|
result.AddRange("pause:long");
|
|
break;
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
private char[] GetAnimationIndex(FileReader reader, short secondaryType)
|
|
{
|
|
List<char> result = new List<char>();
|
|
|
|
switch (secondaryType)
|
|
{
|
|
case 0:
|
|
throw new FormatException();
|
|
case 1:
|
|
result.AddRange($"Anim:{ reader.ReadUInt16() }");
|
|
break;
|
|
case 2:
|
|
break;
|
|
case 3:
|
|
break;
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
private char[] GetSoundIndex(FileReader reader, short secondaryType)
|
|
{
|
|
List<char> result = new List<char>();
|
|
|
|
switch (secondaryType)
|
|
{
|
|
case 1:
|
|
break;
|
|
case 2:
|
|
short stringIDSize = (short)(reader.ReadInt16() / 2);
|
|
result.AddRange("Sound:");
|
|
for (int i = 0; i < stringIDSize; i++)
|
|
result.Add((char)reader.ReadInt16());
|
|
break;
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
private char[] GetPlayerInput(FileReader reader, short secondaryType)
|
|
{
|
|
List<char> result = new List<char>();
|
|
|
|
switch (secondaryType)
|
|
{
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
result.AddRange("choice:");
|
|
reader.BaseStream.Position -= 2;
|
|
short numChoices = (short)(reader.ReadInt16() / 2);
|
|
for (int i = 0; i < numChoices; i++)
|
|
{
|
|
if (i != 0)
|
|
result.Add(',');
|
|
result.AddRange($"{ reader.ReadInt16() }");
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
}
|
|
|
|
public class NLI1 : MSBTEntry
|
|
{
|
|
public List<Tuple<uint, int>> Entries = null;
|
|
|
|
public override void Read(FileReader reader, Header header)
|
|
{
|
|
Entries = new List<Tuple<uint, int>>();
|
|
|
|
Padding = reader.ReadBytes(8);
|
|
EntryCount = reader.ReadUInt32();
|
|
|
|
for (int i = 0; i < EntryCount; i++)
|
|
{
|
|
uint MessageID = reader.ReadUInt32();
|
|
int MessageIndex = reader.ReadInt32();
|
|
|
|
Entries.Add(Tuple.Create(MessageID, MessageIndex));
|
|
}
|
|
}
|
|
|
|
public override void Write(FileWriter writer, Header header)
|
|
{
|
|
writer.Write(Padding);
|
|
writer.Write(Entries.Count);
|
|
for (int i = 0; i < Entries.Count; i++)
|
|
{
|
|
writer.Write(Entries[i].Item1); //MessageID
|
|
writer.Write(Entries[i].Item2); //MessageIndex
|
|
}
|
|
}
|
|
}
|
|
|
|
public class LBL1 : MSBTEntry
|
|
{
|
|
public List<LabelGroup> Groups = new List<LabelGroup>();
|
|
public List<LabelEntry> Labels = new List<LabelEntry>();
|
|
|
|
public override void Read(FileReader reader, Header header)
|
|
{
|
|
Padding = reader.ReadBytes(8);
|
|
long pos = reader.Position;
|
|
EntryCount = reader.ReadUInt32();
|
|
|
|
for (int i = 0; i < EntryCount; i++)
|
|
{
|
|
LabelGroup group = new LabelGroup();
|
|
group.NumberOfLabels = reader.ReadUInt32();
|
|
group.Offset = reader.ReadUInt32();
|
|
Groups.Add(group);
|
|
}
|
|
|
|
foreach (LabelGroup group in Groups)
|
|
{
|
|
reader.Seek(pos + group.Offset, SeekOrigin.Begin);
|
|
for (int i = 0; i < group.NumberOfLabels; i++)
|
|
{
|
|
LabelEntry entry = new LabelEntry();
|
|
entry.Length = reader.ReadByte();
|
|
entry.Name = reader.ReadString((int)entry.Length);
|
|
entry.Index = reader.ReadUInt32();
|
|
entry.Checksum = (uint)Groups.IndexOf(group);
|
|
Labels.Add(entry);
|
|
}
|
|
}
|
|
|
|
reader.Align(8);
|
|
}
|
|
|
|
public override void Write(FileWriter writer, Header header)
|
|
{
|
|
writer.Seek(8);
|
|
|
|
long pos = writer.Position;
|
|
writer.Write(Groups.Count);
|
|
for (int i = 0; i < Groups.Count; i++) {
|
|
writer.Write(Groups[i].NumberOfLabels);
|
|
writer.Write(uint.MaxValue);
|
|
}
|
|
|
|
int index = 0;
|
|
for (int g = 0; g < Groups.Count; g++) {
|
|
writer.WriteUint32Offset(pos + 8 + (g * 8), pos);
|
|
for (int i = 0; i < Groups[g].NumberOfLabels; i++)
|
|
{
|
|
writer.Write((byte)Labels[index].Name.Length);
|
|
writer.WriteString(Labels[index].Name, Labels[index].Length);
|
|
writer.Write(Labels[index].Index);
|
|
|
|
index++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void WriteSection(FileWriter writer, Header header, string magic, MSBTEntry section)
|
|
{
|
|
long startPos = writer.Position;
|
|
writer.WriteSignature(magic);
|
|
writer.Write(uint.MaxValue);
|
|
section.Write(writer, header);
|
|
long endPos = writer.Position;
|
|
|
|
writer.AlignBytes(16, 0xAB);
|
|
//Skip 20 bytes from the header
|
|
writer.WriteSectionSizeU32(startPos + 4, startPos + 0x10, endPos);
|
|
}
|
|
|
|
public class MSBTEntry
|
|
{
|
|
public byte[] Data;
|
|
public string Signature;
|
|
public byte[] Padding = new byte[8];
|
|
public uint EntryCount;
|
|
|
|
public virtual void Read(FileReader reader, Header header)
|
|
{
|
|
|
|
}
|
|
public virtual void Write(FileWriter writer, Header header)
|
|
{
|
|
writer.Write(Padding);
|
|
writer.Write(Data);
|
|
}
|
|
}
|
|
}
|
|
}
|