public void PrintDuplicationWarnings()
{
foreach (string warn in m_dupeWarnings)
{
CTDebug.Warn(warn);
}
m_dupeWarnings.Clear();
}
public static void Write(this BinaryWriter writer, MdbPacket packet)
{
writer.WriteAscii(packet.Signature, 4);
writer.Write(packet.Size);
long mark1 = writer.BaseStream.Position;
switch (packet.Signature)
{
case "RIGD":
writer.WriteMdbPacket((MdbPacket_RIGD)packet);
break;
case "SKIN":
writer.WriteMdbPacket((MdbPacket_SKIN)packet);
break;
case "COL2":
case "COL3":
writer.WriteMdbPacket((MdbPacket_COLN)packet);
break;
case "COLS":
writer.WriteMdbPacket((MdbPacket_COLS)packet);
break;
case "WALK":
writer.WriteMdbPacket((MdbPacket_WALK)packet);
break;
case "HOOK":
writer.WriteMdbPacket((MdbPacket_HOOK)packet);
break;
case "TRRN":
writer.WriteMdbPacket((MdbPacket_TRRN)packet);
break;
case "HELM":
writer.WriteMdbPacket((MdbPacket_HELM)packet);
break;
case "HAIR":
writer.WriteMdbPacket((MdbPacket_HAIR)packet);
break;
default:
CTDebug.Error("Unrecognized object format: {0}", packet.Signature);
break;
}
long mark2 = writer.BaseStream.Position;
if (mark2 - mark1 != packet.Size)
{
CTDebug.Error("Incorrectly sized packet!");
}
}
public static ColumnInfo Parse(string data)
{
string[] split = data.Split(':');
if (split.Length < 2)
{
throw new FormatException("Not enough values to parse column info");
}
string name = split[0];
ColumnType ctype = ColumnType.String;
switch (split[1].ToLowerInvariant())
{
case "index": ctype = ColumnType.Index; break;
case "label": ctype = ColumnType.Label; break;
case "string": ctype = ColumnType.String; break;
case "scriptconst": ctype = ColumnType.ScriptConst; break;
case "integer": ctype = ColumnType.Integer; break;
case "flags": ctype = ColumnType.Flags; break;
case "float": ctype = ColumnType.Float; break;
case "tableref": ctype = ColumnType.TableRef; break;
case "columnref": ctype = ColumnType.ColumnRef; break;
case "scriptref": ctype = ColumnType.ScriptRef; break;
case "tlkref": ctype = ColumnType.TLKRef; break;
case "enum": ctype = ColumnType.Enum; break;
default:
CTDebug.Error("Could not parse column type: {0}", split[1]);
break;
}
string refTo = "";
if (split.Length == 3)
{
refTo = split[2];
}
return(new ColumnInfo(name, ctype, refTo));
}
public void ResolveReferences()
{
foreach (string colName in m_data.Keys)
{
try
{
m_data[colName].ResolveRef(InTable.GetColumn(colName));
}
catch (Exception)
{
CTDebug.Error("Could not resolve reference in table {0}, row {1} column {2}", InTable.Name, Index, colName);
m_data[colName].FromDataString("****", new ColumnInfo("string", ColumnType.String));
InTable.CanSave = false;
}
}
HasUnresolvedReferences = false;
}
public void Load(string path)
{
if (File.Exists(path))
{
string[] input = File.ReadAllLines(path);
for (int i = 0; i < input.Length; ++i)
{
if (input[i][0] == '!')
{
Group = input[i].Substring(1);
}
else if (input[i][0] == '@')
{
switch (input[i].Substring(1).ToLowerInvariant())
{
case "minify":
Minify = true;
break;
}
}
else
{
try
{
ColumnInfo readInfo = ColumnInfo.Parse(input[i]);
int colIndex = this.FindIndex((ColumnInfo checkColumn) => { return(checkColumn.Name == readInfo.Name); });
if (colIndex >= 0 && this[colIndex].Name == readInfo.Name)
{
this[colIndex] = readInfo;
}
else
{
CTDebug.Warn("Could not find column {0}", readInfo.Name);
}
}
catch (FormatException e)
{
CTDebug.Error(e.ToString());
}
}
}
}
}
public void Read(string filename)
{
BinaryReader reader = new BinaryReader(File.OpenRead(filename));
m_header = reader.ReadMdbFileHeader();
for (int i = 0; i < m_header.NumPackets; ++i)
{
m_packetHeaders.Add(reader.ReadMdbPacketHeader());
}
for (int i = 0; i < m_header.NumPackets; ++i)
{
if (reader.BaseStream.Position != m_packetHeaders[i].Offset)
{
CTDebug.Warn("At position {0}, expecting {1}", reader.BaseStream.Position, m_packetHeaders[i].Offset);
reader.BaseStream.Seek(m_packetHeaders[i].Offset, SeekOrigin.Begin);
}
m_packets.Add(reader.ReadMdbPacket());
}
}
public void ResolveReferences()
{
if (HasUnresolvedReferences)
{
CTDebug.Info("Resolving references in {0}", Name);
foreach (ColumnInfo col in m_columns)
{
if (col.Type == ColumnType.TableRef)
{
TableDocument table = CTCore.GetOpenProject().GetDocument <TableDocument>(col.ReferenceTo);
table.PrintDuplicationWarnings();
}
}
foreach (DataRow row in m_docRows)
{
row.ResolveReferences();
}
HasUnresolvedReferences = false;
}
}
public override void Compile()
{
List <TlkContents> ret = new List <TlkContents>();
List <TlkDocument> docStack = CTCore.GetOpenProject().GetTlkStack().GetDocuments();
for (int i = 0; i < docStack.Count; ++i)
{
TlkDocument doc = docStack[i];
CTDebug.Info("Writing from {0}.tlk ({1} lines)", doc.Name, doc.Contents.Length);
ret.AddRange(doc.Contents);
}
try
{
TLKWriter.SaveFileContents(Path, ret.ToArray());
}
catch (Exception)
{
CTDebug.Error("Could not save {0}. Make sure the file is not in use.", Path);
}
}
public static void Run(string[] args)
{
string inDir, outDir;
int increment;
inDir = "in";
Console.WriteLine("Please enter how many lines to increment");
increment = Int32.Parse(Console.ReadLine());
//Console.WriteLine("Please enter the output directory");
outDir = "out";
foreach (string path in Directory.EnumerateFiles(inDir))
{
string fileName = path.Split('\\').Last();
if (path.ToLowerInvariant().EndsWith(".mdb"))
{
string[] nameParts = fileName.Split('.')[0].Split('_');
string newName;
string newNumberPart;
if (nameParts.Length != 4)
{
Cloaktower.CTDebug.Warn("Encountered bad filename: {0}", fileName);
File.Copy(path, Path.Combine(outDir, fileName), true);
continue;
}
else
{
string numberPart = nameParts[3];
int numberIndex = numberPart.IndexOfAny(new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }, 0);
int number = int.Parse(numberPart.Substring(numberIndex, numberPart.Length - numberIndex)) + increment;
newNumberPart = numberPart.Substring(0, numberIndex) + (number < 10?"0":"") + (number.ToString());
nameParts[3] = newNumberPart;
newName = string.Join("_", nameParts);
}
MdbDocument doc = new Cloaktower.MDB.MdbDocument(path);
doc.Read(path);
string filePrefix = fileName.Split('.')[0];
foreach (MdbPacket packet in doc.GetPackets())
{
if (packet is NamedMdbPacket)
{
NamedMdbPacket named = (NamedMdbPacket)packet;
if (named.Name.Contents.ToLowerInvariant() == (filePrefix.ToLowerInvariant()))
{
string[] subNameParts = named.Name.Contents.Split('_');
subNameParts[3] = newNumberPart;
CTDebug.Info("Renaming {0} to {1}", named.Name.Contents, string.Join("_", subNameParts));
named.Name.Contents = string.Join("_", subNameParts);
}
}
}
doc.Write(Path.Combine(outDir, newName + ".MDB"));
}
else
{
File.Copy(path, Path.Combine(outDir, fileName), true);
}
}
}
public static void Run(string[] args)
{
string inDir = "in", outDir = "out";
//Console.WriteLine("Please enter the input directory");
//inDir = Console.ReadLine();
//Console.WriteLine("Please enter the output directory");
//outDir = Console.ReadLine();
foreach (string path in Directory.EnumerateFiles(inDir))
{
string fileName = path.Split('\\').Last();
if (path.ToLowerInvariant().EndsWith(".mdb"))
{
string[] nameParts = fileName.Split('.')[0].Split('_');
string newName;
int number;
if (nameParts.Length != 3)
{
Cloaktower.CTDebug.Warn("Encountered bad filename: {0}", fileName);
File.Copy(path, Path.Combine(outDir, fileName), true);
continue;
}
else
{
number = int.Parse(nameParts[2].Substring(4, 2)) + 30;
nameParts[2] = nameParts[2].Substring(0, 4) + (number).ToString();
newName = string.Join("_", nameParts);
}
MdbDocument doc = new Cloaktower.MDB.MdbDocument(path);
doc.Read(path);
string filePrefix = fileName.Split('.')[0];
foreach (MdbPacket packet in doc.GetPackets())
{
if (packet is NamedMdbPacket)
{
NamedMdbPacket named = (NamedMdbPacket)packet;
if (named.Signature == "SKIN")
{
string[] split = named.Name.Contents.Split('_');
split[2] = split[2].Substring(0, split[2].Length - 2) + (number).ToString();
string newInternalName = named.Name.Contents.Substring(0, named.Name.Contents.Length - 2) + (number).ToString();
CTDebug.Info("Renaming {0} to {1}", named.Name.Contents, newInternalName);
named.Name.Contents = newInternalName;
if (split[2].Substring(0, 4) == "Head" && split.Length == 3)
{
newName = newInternalName;
}
}
else if (named.Signature == "RIGD")
{
CTDebug.Warn("Found a RIGD in {0}", fileName);
}
}
}
doc.Write(Path.Combine(outDir, newName + ".mdb"));
}
else
{
File.Copy(path, Path.Combine(outDir, fileName), true);
}
}
}
public static MdbPacket ReadMdbPacket(this BinaryReader reader)
{
string Signature = reader.ReadAscii(4);
UInt32 Size = reader.ReadUInt32();
MdbPacket ret = null;
long debugCheckPos = reader.BaseStream.Position;
switch (Signature)
{
case "RIGD":
ret = reader.ReadMdbPacket_RIGD(Size);
break;
case "SKIN":
ret = reader.ReadMdbPacket_SKIN(Size);
break;
case "COL2":
case "COL3":
ret = reader.ReadMdbPacket_COLN(Size);
break;
case "COLS":
ret = reader.ReadMdbPacket_COLS(Size);
break;
case "WALK":
ret = reader.ReadMdbPacket_WALK(Size);
break;
case "HOOK":
ret = reader.ReadMdbPacket_HOOK(Size);
break;
case "TRRN":
ret = reader.ReadMdbPacket_TRRN(Size);
break;
case "HELM":
ret = reader.ReadMdbPacket_HELM(Size);
break;
case "HAIR":
ret = reader.ReadMdbPacket_HAIR(Size);
break;
default:
CTDebug.Error("Unrecognized object format: {0}", Signature);
break;
}
long diff = reader.BaseStream.Position - debugCheckPos;
if (diff != Size)
{
CTDebug.Warn("Invalid size of MDB Packet.");
}
ret.Size = Size;
ret.Signature = Signature;
return(ret);
}
public override void Compile()
{
HakHeader header = new HakHeader();
List <HakKeyEntry> keys = new List <HakKeyEntry>();
List <HakResEntry> resEntries = new List <HakResEntry>();
List <Byte[]> resources = new List <byte[]>();
foreach (KeyValuePair <string, CTArtifact> pair in m_afx)
{
if (!File.Exists(pair.Value.Path))
{
continue;
}
HakKeyEntry key = new HakKeyEntry();
key.ResID = keys.Count;
key.Resref = pair.Key;
key.ResType = pair.Value.ErfID;
key.Reserved = 0;
keys.Add(key);
byte[] resVal = File.ReadAllBytes(pair.Value.Path);
resources.Add(resVal);
HakResEntry res = new HakResEntry();
res.ResourceSize = resVal.Length;
resEntries.Add(res);
}
try
{
if (File.Exists(Path))
{
File.Delete(Path);
}
BinaryWriter writer = new BinaryWriter(File.OpenWrite(Path));
header.Header = "HAK V1.1";
header.StringTableSize = 0;
header.StringCount = 0;
header.EntryCount = keys.Count;
header.OffsetToString = HakHeader.Size;
header.OffsetToKeyList = HakHeader.Size;
header.OffsetToResources = HakHeader.Size + (keys.Count * HakKeyEntry.Size);
header.BuildYear = DateTime.Now.Year - 1900;
header.BuildDay = DateTime.Now.Day;
header.DescriptionIndex = 0;
header.Write(writer);
foreach (var key in keys)
{
key.Write(writer);
}
int ResourceOffset = header.OffsetToResources + (resEntries.Count * HakResEntry.Size);
for (int i = 0; i < resEntries.Count; ++i)
{
resEntries[i].OffsetToResource = ResourceOffset;
resEntries[i].Write(writer);
ResourceOffset += resEntries[i].ResourceSize;
}
for (int i = 0; i < resources.Count; ++i)
{
writer.Write(resources[i]);
}
writer.Flush();
}
catch (Exception)
{
CTDebug.Error("Could not save {0}. Make sure the file is not in use.", Path);
}
}
