protected void ExtractSvo(string SvoPath)
{
//try
//{
using (var _SvoStream = File.OpenRead(SvoPath))
{
Stream SvoStream = _SvoStream;
int Compressed = TalesCompression.DetectVersion(SvoStream.Slice().ReadBytes(16), SvoStream.Length);
if (Compressed >= 0)
{
SvoStream = TalesCompression.DecompressStream(SvoStream);
}
if (SvoStream.SliceWithLength().ReadString(7) == "TO8SCEL")
{
var TO8SCEL = new TO8SCEL(SvoStream);
foreach (var Entry in TO8SCEL)
{
Console.WriteLine("{0} ... Start: {1}, End: {2}, Length: {3}", Entry.Index, Entry.EntryStruct.Offset, Entry.EntryStruct.Offset + Entry.EntryStruct.LengthCompressed, Entry.EntryStruct.LengthCompressed);
}
}
else
{
var FPS4 = new FPS4(SvoStream);
Console.WriteLine("{0}", FPS4);
foreach (var Entry in FPS4)
{
Console.WriteLine("{0} ... Start: {1}, End: {2}, Length: {3}", Entry.Name, Entry.EntryStruct.Offset, Entry.EntryStruct.Offset + Entry.EntryStruct.LengthReal, Entry.EntryStruct.LengthReal);
}
}
}
}
protected void CompressFile(int Version, string UncompressedFile, string CompressedFile = null)
{
if (CompressedFile == null)
{
CompressedFile = String.Format("{0}.c", UncompressedFile);
}
var Compression = TalesCompression.CreateFromVersion(Version);
if (CompressedFile == UncompressedFile)
{
throw (new Exception("Compressed and uncompressed files can't be the same"));
}
Console.Write("{0} -> {1}...", UncompressedFile, CompressedFile);
//var Uncompressed = File.ReadAllBytes(UncompressedFile);
//TalesCompression.CreateFromVersion(1).EncodeFile();
//var Compressed = complib.Encode(3, Uncompressed);
//File.WriteAllBytes(CompressedFile, Compressed);
var Start = DateTime.UtcNow;
using (var In = File.OpenRead(UncompressedFile))
using (var Out = File.Open(CompressedFile, FileMode.Create, FileAccess.Write, FileShare.None))
{
Compression.EncodeFile(In, Out);
}
var End = DateTime.UtcNow;
Console.WriteLine("Ok({0})", (End - Start).TotalSeconds);
//Console.WriteLine(Version);
}
protected void Init(Stream StreamChatSvoOriginal, Stream StreamChatSvoTranslate, Stream StreamAcmeSkits)
{
//TalesCompression = new TalesCompression1_3(3);
TalesCompression = new TalesCompression15_Lzx();
PAK = new FPS4(StreamChatSvoOriginal);
PAKOutput = StreamChatSvoTranslate;
ACME1 = new ACME1(StreamAcmeSkits, Encoding.GetEncoding("ISO-8859-1"));
}
/// <summary>
///
/// </summary>
/// <param name="DatPath"></param>
/// <param name="DavPath"></param>
/// <param name="OutputDirectory"></param>
protected void ExtractSvo2(string DatPath, string DavPath, string OutputDirectory = null)
{
if (DavPath == null)
{
DavPath = DatPath;
}
if (OutputDirectory == null)
{
OutputDirectory = DatPath + ".d";
}
Console.WriteLine("Loading {0}...", DatPath);
//try
//{
using (var _Stream1 = File.OpenRead(DatPath))
using (var Stream2 = File.OpenRead(DavPath))
{
var Stream1 = (Stream)_Stream1;
try { Directory.CreateDirectory(OutputDirectory); }
catch { }
int Compressed = TalesCompression.DetectVersion(Stream1.Slice().ReadBytes(16), Stream1.Length);
if (Compressed >= 0)
{
Stream1 = TalesCompression.DecompressStream(Stream1);
}
if (Stream1.SliceWithLength().ReadString(7) == "TO8SCEL")
{
var TO8SCEL = new TO8SCEL(Stream1);
foreach (var Entry in TO8SCEL)
{
_ExtractFile(OutputDirectory + "/" + Entry.Index, () => Entry.UncompressedStream, (int)(uint)Entry.EntryStruct.Offset, (int)(uint)Entry.EntryStruct.LengthCompressed);
}
}
else
{
var FPS4 = new FPS4(Stream1, Stream2);
Console.WriteLine("{0}", FPS4);
foreach (var Entry in FPS4)
{
_ExtractFile(OutputDirectory + "/" + Entry.Name, () => Entry.Open(), (int)(uint)Entry.EntryStruct.Offset, (int)(uint)Entry.EntryStruct.LengthReal);
}
}
}
//}
//catch (Exception Exception)
//{
// Console.Error.WriteLine("{0}", Exception);
//}
}
public void DecompressStream()
{
using (var CompressedStream = File.OpenRead(Utils.TestInputPath + @"\textfile.txt.c1"))
using (var UncompressedStream = TalesCompression.DecompressStream(CompressedStream))
using (var OriginalStream = File.OpenRead(Utils.TestInputPath + @"\textfile.txt"))
{
CollectionAssert.AreEqual(
OriginalStream.ReadAll(),
UncompressedStream.ReadAll()
);
}
}
public void DecompressRecompressStreamIfRequired(Stream CompressedStream, Action <Stream> Action, int RecompressVersion = -1, bool RecompressJustWhenModified = true)
{
if (TalesCompression.DetectVersion(CompressedStream.Slice()) == -1)
{
Action(CompressedStream);
}
else
{
using (var UncompressedStream = new DecompressRecompressStream(CompressedStream, RecompressVersion, RecompressJustWhenModified))
{
Action(UncompressedStream);
}
}
}
private void CompressRooms()
{
if (Patcher.TempFS.Exists("scenario_es.dat"))
{
return;
}
this.Patcher.ProgressHandler.AddProgressLevel("Comprimiendo habitaciones", RoomCount, () =>
{
var NewTO8SCEL = new TO8SCEL();
Patcher.ParallelForeach("Compressing Room", Iterators.IntRange(0, RoomCount - 1), (RoomId) => RoomId.ToString(), (RoomId) =>
{
this.Patcher.ProgressHandler.IncrementLevelProgress();
var ScenarioTempFileName = ScenarioTempFileNamePrep + RoomId;
var ScenarioTempFileCompressedName = ScenarioTempFileName + ".c";
if (Patcher.TempFS.Exists(ScenarioTempFileName))
{
if (!Patcher.TempFS.Exists(ScenarioTempFileCompressedName))
{
var UncompressedBytes = Patcher.TempFS.ReadAllBytes(ScenarioTempFileName);
var CompressedBytes = TalesCompression.CreateFromVersion(Patcher.CompressionVersion, Patcher.CompressionVersion).EncodeBytes(UncompressedBytes);
Patcher.TempFS.WriteAllBytes(ScenarioTempFileCompressedName, CompressedBytes);
}
NewTO8SCEL.CreateEntry(
RoomId,
Patcher.TempFS.OpenFileRead(ScenarioTempFileCompressedName),
Patcher.TempFS.OpenFileRead(ScenarioTempFileName)
);
}
else
{
NewTO8SCEL.CreateEntry(
RoomId,
new MemoryStream(),
new MemoryStream()
);
}
});
Patcher.TempFS.OpenFileCreateScope("scenario_es.dat", (Stream) =>
{
NewTO8SCEL.SaveTo(Stream);
Stream.Position = 0;
});
});
}
public void DecompressAndRecompressIfRequired(Stream Stream, Action <Stream> Action, int RecompressVersion = -1)
{
if (TalesCompression.IsValid(Stream))
{
using (var UncompressedStream = new DecompressRecompressStream(Stream, RecompressVersion))
{
Action(UncompressedStream);
}
}
else
{
Action(Stream);
}
}
private Stream DecompressIfCompressedStream(Stream FileStream)
{
var MagicData = FileStream.Slice().ReadBytesUpTo(0x100);
// Decompress if compressed
try
{
if (TalesCompression.DetectVersion(MagicData, FileStream.Length) != -1)
{
return(TalesCompression.DecompressStream(FileStream));
}
}
catch
{
}
return(FileStream);
}
protected void CompressFile(int Version, string UncompressedFile)
{
try
{
var Start = DateTime.UtcNow;
var Compression = TalesCompression.CreateFromVersion(Version);
var Uncompressed = File.ReadAllBytes(UncompressedFile);
var Compressed = Compression.EncodeBytes(Uncompressed);
var Uncompressed2 = Compression.DecodeBytes(Compressed);
if (Uncompressed.Length != Uncompressed2.Length)
{
Console.Error.WriteLine("Length mismatch {0} != {1}", Uncompressed.Length, Uncompressed2.Length);
}
var Offsets = new List <int>();
for (int n = 0; n < Uncompressed.Length; n++)
{
if (Uncompressed[n] != Uncompressed2[n])
{
Offsets.Add(n);
}
}
if (Offsets.Count > 0)
{
foreach (var Offset in Offsets.Take(100))
{
Console.Error.WriteLine(" {0:X8}: {1:X2} != {2:X2}", Offset, Uncompressed[Offset], Uncompressed2[Offset]);
}
if (Offsets.Count > 100)
{
Console.WriteLine(" ...");
}
throw (new Exception(String.Format("Mismatches: [{0}], {1}", String.Join(",", Offsets.Take(100)), Offsets.Count)));
}
var End = DateTime.UtcNow;
Console.WriteLine("Ok({0})", (End - Start).TotalSeconds);
}
catch (Exception Exception)
{
Console.WriteLine("Error({0})", Exception);
}
}
public void HandleBattlePackDialogs(Stream OldStream, Stream NewStream)
{
FPS4 OldFps4;
FPS4 NewFps4;
OldFps4 = new FPS4(OldStream.Slice());
NewFps4 = new FPS4(OldStream.Slice()); // Intended OldStream
var TranslatedFiles = new ConcurrentDictionary <string, MemoryStream>();
var Names = new[]
{
"BTL_EP_0070_010", "BTL_EP_030_040", "BTL_EP_030_080", "BTL_EP_0950_010",
"BTL_EP_0960_020", "BTL_EP_1040_020", "BTL_EP_150_170", "BTL_EP_170_050",
"BTL_EP_210_090", "BTL_EP_270_110", "BTL_EP_270_110_1", "BTL_EP_340_070",
"BTL_EP_370_050", "BTL_EP_420_080", "BTL_EP_440_040", "BTL_EP_470_030",
"BTL_EP_490_060_0", "BTL_EP_490_060_1", "BTL_EP_510_050", "BTL_EP_510_080",
"BTL_EP_640_050", "BTL_EP_650_030", "BTL_EP_650_050", "BTL_LL_MONSTER",
"MA_VAL_A_05",
};
Patcher.Action("Translating Battle Scripts", () =>
{
Patcher.ProgressHandler.AddProgressLevel("Traduciendo scripts de batalla...", Names.Length, () =>
{
Patcher.ParallelForeach("Translating", Names, (Name) => Name, (Name) =>
{
using (var CompressedTssStream = OldFps4[Name].Open())
{
using (var TssStream = TalesCompression.DecompressStream(CompressedTssStream))
{
var TssName = Name;
var Tss = new TSS().Load(TssStream);
Tss.TranslateTexts((Entry) =>
{
//if (Entry == null) return;
var TranslationEntry = Patcher.EntriesByRoom["battle/" + TssName][String.Format("{0:X8}", Entry.Id2)];
int TextCount = Entry.Original.Length;
Entry.TranslateWithTranslationEntry(TranslationEntry);
//Console.WriteLine("{0} : {1}", Entry.Translated[1], TranslationEntry.texts.es[1]);
}, (String) =>
{
return(null);
});
var TranslatedCompressedStream = TalesCompression.CreateFromVersion(Patcher.CompressionVersion, Patcher.CompressionFallback).EncodeFile(Tss.Save());
TranslatedFiles[Name] = TranslatedCompressedStream;
}
}
Patcher.ProgressHandler.IncrementLevelProgress();
});
});
});
Patcher.Action("Reconstructing Battle Scripts Package", () =>
{
NewFps4.ClearAllEntries();
foreach (var Entry in OldFps4.Entries.Values)
{
var EntryName = Entry.Name;
if (TranslatedFiles.ContainsKey(EntryName))
{
NewFps4.CreateEntry(EntryName, TranslatedFiles[EntryName]);
}
else
{
NewFps4.CreateEntry(EntryName, Entry.Open());
}
}
NewFps4.SaveTo(NewStream, DoAlign: false);
});
}
protected void DecompressFile(string CompressedFile, string UncompressedFile = null)
{
if (CompressedFile.Contains('*'))
{
var BaseDirectory = Path.GetDirectoryName(CompressedFile);
if (BaseDirectory == "")
{
BaseDirectory = ".";
}
if (UncompressedFile != null)
{
if (!Directory.Exists(UncompressedFile))
{
Directory.CreateDirectory(UncompressedFile);
}
}
foreach (var CompressedFile2 in Directory.EnumerateFiles(BaseDirectory, Path.GetFileName(CompressedFile)))
{
var BaseName = Path.GetFileName(CompressedFile2);
if (UncompressedFile == null)
{
DecompressFile(CompressedFile2, null);
}
else
{
var Out = UncompressedFile + Path.DirectorySeparatorChar + BaseName + ".u";
DecompressFile(CompressedFile2, Out);
}
}
return;
}
if (UncompressedFile == null)
{
UncompressedFile = CompressedFile + ".u";
}
if (CompressedFile == UncompressedFile)
{
throw(new Exception("Compressed and uncompressed files can't be the same"));
}
Console.Write("{0} -> {1}...", CompressedFile, UncompressedFile);
try
{
var Start = DateTime.UtcNow;
using (var CompressedStream = File.OpenRead(CompressedFile))
using (var UncompressedStream = File.Open(UncompressedFile, FileMode.Create, FileAccess.Write, FileShare.None))
{
var Compression = TalesCompression.CreateFromStart(CompressedStream.Slice().ReadBytes(0x10), CompressedStream.Length);
Compression.DecodeFile(CompressedStream, UncompressedStream);
}
var End = DateTime.UtcNow;
Console.WriteLine("Ok({0})", (End - Start).TotalSeconds);
}
catch (Exception Exception)
{
Console.WriteLine("Error({0})", Exception.Message);
}
}
private void Handle1()
{
Patcher.TempFS.CreateDirectory("CHAT_ES", 0777, false);
Patcher.Action("Translating Skits...", () =>
{
Patcher.ProgressHandler.AddProgressLevel("Traduciendo skits", OriginalChatSvo.Count(), () =>
{
Patcher.ParallelForeach("Translating", OriginalChatSvo, (ChatSvoEntry) => ChatSvoEntry.Name, (ChatSvoEntry) =>
{
var Match = ChatSvoEntry.Name.RegexMatch(@"^(VC\d+B?)(UK)\.DAT$");
if (Match != null)
{
var CompleteFile = Match[0].Value;
var ChatId = Match[1].Value;
var EsFile = PreppendTempFile + ChatId + "ES.DAT";
Console.WriteLine("{0}...", ChatId);
if (!Patcher.TempFS.Exists(EsFile))
{
var Fps4 = new FPS4(TalesCompression.DecompressStream(OriginalChatSvo[CompleteFile].Open()));
{
var Chtx = new TO8CHTX();
Chtx.Load(Fps4["3"].Open());
// Translate
{
foreach (var Entry in Patcher.EntriesByRoom["skits/" + ChatId].Values)
{
int TextId = int.Parse(Entry.text_id) - 1;
if (TextId >= 0)
{
//Chtx[TextId].Title = "";
//Chtx[TextId].Title = TextProcessor.Instance.ProcessAndDetectPitfalls(Chtx[TextId].Title, Entry.texts.es[0].TrimEnd(' ', '\t', '\n', '\r', '.'));
//Chtx[TextId].Title = TextProcessor.Instance.ProcessAndDetectPitfalls(Chtx[TextId].Title, Entry.texts.es[0]);
Chtx[TextId].Title = "";
Chtx[TextId].TextOriginal = "";
Chtx[TextId].TextTranslated = TextProcessor.Instance.ProcessAndDetectPitfalls(Chtx[TextId].TextTranslated, Entry.texts.es[1]);
}
}
}
//ChtxStream.SetLength(0);
var ChtxStream = new MemoryStream();
Chtx.SaveTo(ChtxStream);
ChtxStream.Position = 0;
Fps4["3"].SetStream(ChtxStream);
}
Patcher.TempFS.WriteAllBytes(EsFile, TalesCompression.CreateFromVersion(Patcher.CompressionVersion, Patcher.CompressionFallback).EncodeBytes(Fps4.Save(false).ToArray()));
Console.WriteLine("{0}...Ok", ChatId);
}
else
{
Console.WriteLine("{0}...Exists", ChatId);
}
}
Patcher.ProgressHandler.IncrementLevelProgress();
});
});
});
}
