public void CreateWithStream()
{
using (var db = StringDatabase.Create(new MemoryStream()))
{
Insert(db);
db.Should()
.BeOfType <TransformDatabase <byte[], byte[], string, string> >();
}
}
public void CreateWithStreamAndVersion(StringDBVersion version)
{
using (var db = StringDatabase.Create(new MemoryStream(), version, false))
{
Insert(db);
db.Should()
.BeOfType <TransformDatabase <byte[], byte[], string, string> >();
}
}
public void Create()
{
using (var db = StringDatabase.Create())
{
Insert(db);
db.Should()
.BeOfType <MemoryDatabase <string, string> >();
}
}
public static long GetSizeAfter(int kvps, Action <IDatabase <string, string>, int> action)
{
using (var ms = new MemoryStream())
using (var db = StringDatabase.Create(ms))
{
action(db, kvps);
return(ms.Length);
}
}
public void CreateWithStreamAndVersion(StringDBVersions version)
{
using (var db = StringDatabase.Create(new MemoryStream(), version, false))
{
db.Insert("init", "Hello, World!");
db.Get("init").Should().Be("Hello, World!");
db.Should()
.BeOfType <TransformDatabase <byte[], byte[], string, string> >();
}
}
public void Create()
{
using (var db = StringDatabase.Create())
{
db.Insert("init", "Hello, World!");
db.Get("init").Should().Be("Hello, World!");
db.Should()
.BeOfType <MemoryDatabase <string, string> >();
}
}
/// <summary>
/// Initializes the <see cref="PresentationStrings"/> type.
/// </summary>
static PresentationStrings()
{
var asm = Assembly.GetExecutingAssembly();
using (var stream = asm.GetManifestResourceStream("Ultraviolet.Presentation.Resources.Strings.xml"))
{
StringDatabase.LoadFromStream(stream);
}
using (var stream = asm.GetManifestResourceStream("Ultraviolet.Presentation.Resources.Commands.xml"))
{
StringDatabase.LoadFromStream(stream);
}
}
public static long GetSizeAfter(int times, Action <IDatabase <string, string> > action)
{
using (var ms = new MemoryStream())
using (var db = StringDatabase.Create(ms))
{
for (var i = 0; i < times; i++)
{
action(db);
}
return(ms.Length);
}
}
private static void Main()
{
// this is the most simplest way to use StringDB
// this creates a database in RAM
using (var db = StringDatabase.Create())
{
// we can insert stuff
db.Insert("key", "Hello, World!");
// get that value
var value = db.Get("key");
// write it to the console
Console.WriteLine(value);
}
}
public void IntegrationTest()
{
if (File.Exists("stringdb.db"))
{
File.Delete("stringdb.db");
}
using (var db = StringDatabase.Create(File.Open("stringdb.db", FileMode.OpenOrCreate)))
{
db.Insert("test", "value");
db.Insert("test", "value2");
db.Insert("test", "value3");
db.EnumerateAggressively(3)
.Should().BeEquivalentTo(new[]
{
new KeyValuePair <string, string>("test", "value"),
new KeyValuePair <string, string>("test", "value2"),
new KeyValuePair <string, string>("test", "value3"),
});
}
using (var db = StringDatabase.Create(File.Open("stringdb.db", FileMode.OpenOrCreate)))
{
db.Insert("test", "value4");
db.EnumerateAggressively(3)
.Should().BeEquivalentTo(new[]
{
new KeyValuePair <string, string>("test", "value"),
new KeyValuePair <string, string>("test", "value2"),
new KeyValuePair <string, string>("test", "value3"),
new KeyValuePair <string, string>("test", "value4")
});
}
}
public CodeParser(Databases dtbs, IndentationManager oldIndentation)
{
fdtb = dtbs.fdtb;
cdtb = dtbs.cdtb;
sdtb = dtbs.sdtb;
indent = oldIndentation;
block = new CodeBlock();
}
// Insert CAT file to csv
static void InsertCatFile(string catFile, string csvFile)
{
Console.WriteLine($"Processing {catFile}...");
CleanTrados(catFile);
string[] catStrings = File.ReadAllLines(catFile, Encoding.UTF8);
var stringDb = new List <StringDatabase>();
using (var reader = new StreamReader(csvFile, Encoding.GetEncoding("shift-jis")))
{
using (var csv = new CsvReader(reader))
{
csv.Configuration.Delimiter = "\t";
csv.Configuration.IgnoreQuotes = true;
csv.Configuration.MissingFieldFound = null;
csv.Read();
csv.ReadHeader();
while (csv.Read())
{
var record = new StringDatabase
{
Offset = csv.GetField <UInt32>("Offset"),
Hash = csv.GetField <UInt32>("Hash"),
eString = csv.GetField("eString"),
jString = csv.GetField("jString")
};
stringDb.Add(record);
}
}
}
// Copy catStrings to new db
for (int i = 0; i < stringDb.Count; i++)
{
Console.Write($"\rUpdating entry {i + 1}/{stringDb.Count}");
if (stringDb[i].jString != catStrings[i])
{
stringDb[i].eString = catStrings[i];
}
// Allow for deletions
else if (stringDb[i].jString == catStrings[i] && stringDb[i].eString != "")
{
stringDb[i].eString = "";
}
}
Console.WriteLine();
// Using this approach because csvHelper would always escape some strings which might mess up in-game when copy-pasting where required
string fileName = "csv\\" + Path.GetFileName(csvFile);
//string fileName = "test.csv";
if (File.Exists(fileName))
{
File.Delete(fileName);
}
StreamWriter txtOutput = new StreamWriter(fileName, true, Encoding.GetEncoding("shift-jis"));
txtOutput.WriteLine("Offset\tHash\tjString\teString");
foreach (var obj in stringDb)
{
txtOutput.WriteLine($"{obj.Offset}\t{obj.Hash}\t{obj.jString}\t{obj.eString}");
}
txtOutput.Close();
if (!Directory.Exists("backup"))
{
Directory.CreateDirectory("backup");
}
File.Move(catFile, $"backup\\{Path.GetFileNameWithoutExtension(catFile)}_{DateTime.Now.ToString("yyyyMMdd_HHmm")}.txt");
}
// Merge old and updated csvs
static void Merge(string oldCsv, string newCsv)
{
// Read csv
var stringDbOld = new List <StringDatabase>();
using (var reader = new StreamReader(oldCsv, Encoding.GetEncoding("shift-jis")))
{
using (var csv = new CsvReader(reader))
{
csv.Configuration.Delimiter = "\t";
csv.Configuration.IgnoreQuotes = true;
csv.Configuration.MissingFieldFound = null;
csv.Read();
csv.ReadHeader();
while (csv.Read())
{
var record = new StringDatabase
{
Hash = csv.GetField <UInt32>("Hash"),
eString = csv.GetField("eString")
};
stringDbOld.Add(record);
}
}
}
var stringDbNew = new List <StringDatabase>();
using (var reader = new StreamReader(newCsv, Encoding.GetEncoding("shift-jis")))
{
using (var csv = new CsvReader(reader))
{
csv.Configuration.Delimiter = "\t";
csv.Configuration.IgnoreQuotes = true;
csv.Configuration.MissingFieldFound = null;
csv.Read();
csv.ReadHeader();
while (csv.Read())
{
var record = new StringDatabase
{
Offset = csv.GetField <UInt32>("Offset"),
Hash = csv.GetField <UInt32>("Hash"),
eString = csv.GetField("eString"),
jString = csv.GetField("jString")
};
stringDbNew.Add(record);
}
}
}
// Copy eStrings to new db
for (int i = 0; i < stringDbOld.Count; i++)
{
Console.Write($"\rUpdating entry {i+1}/{stringDbOld.Count}");
if (stringDbOld[i].eString != "")
{
var matchedNewObjs = stringDbNew.Where(x => x.Hash.Equals(stringDbOld[i].Hash));
if (matchedNewObjs.Count() > 0)
{
foreach (var obj in matchedNewObjs)
{
obj.eString = stringDbOld[i].eString;
}
}
}
}
Console.WriteLine();
// Using this approach because csvHelper would always escape some strings which might mess up in-game when copy-pasting where required
string fileName = "csv\\" + Path.GetFileName(oldCsv);
if (File.Exists(fileName))
{
File.Delete(fileName);
}
StreamWriter txtOutput = new StreamWriter(fileName, true, Encoding.GetEncoding("shift-jis"));
txtOutput.WriteLine("Offset\tHash\tjString\teString");
foreach (var obj in stringDbNew)
{
txtOutput.WriteLine($"{obj.Offset}\t{obj.Hash}\t{obj.jString}\t{obj.eString}");
}
txtOutput.Close();
File.Delete(newCsv);
}
// Append translations and update pointers
static void InsertStrings(string inputFile, string inputCsv)
{
Console.WriteLine($"Processing {inputFile}...");
byte[] inputArray = File.ReadAllBytes(inputFile);
// Read csv
var stringDatabase = new List <StringDatabase>();
using (var reader = new StreamReader(inputCsv, Encoding.GetEncoding("shift-jis")))
{
using (var csv = new CsvReader(reader))
{
csv.Configuration.Delimiter = "\t";
csv.Configuration.IgnoreQuotes = true;
csv.Configuration.MissingFieldFound = null;
csv.Read();
csv.ReadHeader();
while (csv.Read())
{
var record = new StringDatabase
{
Offset = csv.GetField <UInt32>("Offset"),
Hash = csv.GetField <UInt32>("Hash"),
eString = csv.GetField("eString").
Replace("<TAB>", "\t"). // Replace tab
Replace("<CLINE>", "\r\n"). // Replace carriage return
Replace("<NLINE>", "\n") // Replace new line
};
stringDatabase.Add(record);
}
}
}
// Get info for translation array and get all offsets that need to be remapped
List <UInt32> eStringsOffsets = new List <uint>();
List <Int32> eStringLengths = new List <int>();
foreach (var obj in stringDatabase)
{
if (obj.eString != "")
{
eStringsOffsets.Add(obj.Offset);
eStringLengths.Add(GetNullterminatedStringLength(obj.eString));
}
}
int eStringsLength = eStringLengths.Sum();
int eStringsCount = eStringLengths.Count;
// Create dictionary with offset replacements
Dictionary <int, int> offsetDict = new Dictionary <int, int>();
for (int i = 0; i < eStringsCount; i++)
{
offsetDict.Add((int)eStringsOffsets[i], inputArray.Length + eStringLengths.Take(i).Sum());
}
if (verbose)
{
Console.WriteLine($"Filling array of size {eStringsLength.ToString("X8")}...");
}
byte[] eStringsArray = new byte[eStringsLength];
for (int i = 0, j = 0; i < stringDatabase.Count; i++)
{
if (stringDatabase[i].eString != "")
{
// Write string to string array
int test = eStringLengths.Take(j).Sum();
if (verbose)
{
Console.WriteLine($"String: '{stringDatabase[i].eString}', Length: {eStringLengths[j] - 1}");
}
byte[] eStringArray = Encoding.GetEncoding("shift-jis").GetBytes(stringDatabase[i].eString);
Array.Copy(eStringArray, 0, eStringsArray, eStringLengths.Take(j).Sum(), eStringLengths[j] - 1);
j++;
}
}
// Replace offsets in binary file
for (int p = 0; p < inputArray.Length; p += 4)
{
if (p + 4 > inputArray.Length)
{
continue;
}
int cur = BitConverter.ToInt32(inputArray, p);
if (offsetDict.ContainsKey(cur) && p > 10000)
{
int replacement = 0; offsetDict.TryGetValue(cur, out replacement);
byte[] newPointer = BitConverter.GetBytes(replacement);
for (int w = 0; w < 4; w++)
{
inputArray[p + w] = newPointer[w];
}
}
}
// Combine arrays
byte[] outputArray = new byte[inputArray.Length + eStringsLength];
Array.Copy(inputArray, outputArray, inputArray.Length);
Array.Copy(eStringsArray, 0, outputArray, inputArray.Length, eStringsArray.Length);
// Output file
Directory.CreateDirectory("output");
string outputFile = $"output\\{Path.GetFileName(inputFile)}";
File.WriteAllBytes(outputFile, outputArray);
// Pack with jpk type 0 and encrypt file with ecd
Pack.JPKEncode(0, outputFile, outputFile, 15);
byte[] buffer = File.ReadAllBytes(outputFile);
byte[] bufferMeta = File.ReadAllBytes($"{outputFile}.meta");
buffer = Crypto.encEcd(buffer, bufferMeta);
File.WriteAllBytes(outputFile, buffer);
// Update list
string updEntry = Helpers.GetUpdateEntry(outputFile);
UpdateList(updEntry);
// Upload to ftp
FileUploadSFTP(buffer, $"/var/www/html/mhfo/dat/{Path.GetFileName(inputFile)}");
}
public Writer(Databases dtbs)
{
cdtb = dtbs.cdtb;
fdtb = cdtb.functionDatabase;
sdtb = dtbs.sdtb;
this.dtbs = dtbs;
}
private CodeParser(ClassDatabase cdtb, FunctionDatabase fdtb, StringDatabase sdtb, IndentationManager indentation, Dictionary<string, LocalVariable> loc)
{
this.cdtb = cdtb;
this.sdtb = sdtb;
this.fdtb = fdtb;
indent = indentation;
locals = loc;
block = new CodeBlock();
}
public CodeParser(Databases databases, Function f, IndentationManager lastIndentation)
{
fdtb = databases.fdtb;
cdtb = databases.cdtb;
sdtb = databases.sdtb;
indent = lastIndentation;
int offset = f is LocalFunction ? 1 : 0;
foreach (Argument a in f.arguments)
{
if (!a.isSelfArgument())
{
locals[a.name] = new LocalVariable(locals.Count+offset, a.type);
}
}
if (f is LocalFunction) {
Argument selfArgument = f.arguments.First((x => x.isSelfArgument()));
locals[selfArgument.name]=new LocalVariable(0, selfArgument.type);
}
#if DEBUG
Console.WriteLine("Locals are: " + locals.toAdvancedString());
#endif
block = new CodeBlock();
}
