private static MemoryStream LoadStoryStreamFromSave(String path)
{
using (var packageReader = new PackageReader(path))
{
Package package = packageReader.Read();
AbstractFileInfo globalsFile = package.Files.FirstOrDefault(p => p.Name.ToLowerInvariant() == "globals.lsf");
if (globalsFile == null)
{
throw new Exception("Could not find globals.lsf in savegame archive.");
}
Resource resource;
Stream rsrcStream = globalsFile.MakeStream();
try
{
using (var rsrcReader = new LSFReader(rsrcStream))
{
resource = rsrcReader.Read();
}
}
finally
{
globalsFile.ReleaseStream();
}
LSLib.LS.Node storyNode = resource.Regions["Story"].Children["Story"][0];
var storyBlob = storyNode.Attributes["Story"].Value as byte[];
var storyStream = new MemoryStream(storyBlob);
return(storyStream);
}
}
public void PropertyCanReadStructVectorValueTest2()
{
var pf1 = new PackageReader();
pf1.Read("D:\\la2\\system\\lineageeffect.u");
var header1 = new Header(pf1.Bytes);
var ExportTable1 = new ExportTable(header1, pf1.Bytes);
var ImportTable1 = new ImportTable(header1, pf1.Bytes);
var NameTable1 = new NameTable(header1, pf1.Bytes);
string name = "MeshEmitter0";
Export Exp = ExportTable1[1939];
int PropertyOffset = 0xA + Exp.SerialOffset + 28;
//Act
Property Prop = new Property(pf1.Bytes, PropertyOffset);
Prop.SetStructType(StructType.Vector);
//Assert
string Str = NameTable1[Prop.NameTableRef];
Assert.AreEqual(Str, "Acceleration");
Assert.IsTrue(Prop.Value is DataStructures.UVector);
Assert.AreEqual(Prop.Size, 15);
DataStructures.UVector uv = Prop.Value as DataStructures.UVector;
Assert.AreEqual(Prop.Type, PropertyType.StructProperty);
Assert.AreEqual(uv.X, -13.00f);
Assert.AreEqual(uv.Y, 0.0f);
Assert.AreEqual(uv.Z, -50.0f);
}
private static void ListPackageFiles(string packagePath, Func <AbstractFileInfo, bool> filter = null)
{
try
{
using (var reader = new PackageReader(packagePath))
{
Package package = reader.Read();
List <AbstractFileInfo> files = package.Files;
if (filter != null)
{
files = files.FindAll(obj => filter(obj));
}
foreach (AbstractFileInfo fileInfo in files.OrderBy(obj => obj.Name))
{
Console.WriteLine($"{fileInfo.Name}\t{fileInfo.Size()}\t{fileInfo.CRC()}");
}
}
}
catch (NotAPackageException)
{
CommandLineLogger.LogError("Failed to list package contents because the package is not an Original Sin package or savegame archive");
}
catch (Exception e)
{
CommandLineLogger.LogFatal($"Failed to list package: {e.Message}", 2);
CommandLineLogger.LogTrace($"{e.StackTrace}");
}
}
public static Resource LoadResourceFromSave(string path)
{
var packageReader = new PackageReader(path);
Package package = packageReader.Read();
AbstractFileInfo abstractFileInfo = package.Files.FirstOrDefault(p => p.Name == "globals.lsf");
if (abstractFileInfo == null)
{
MessageBox.Show("The specified package is not a valid savegame (globals.lsf not found)", "Load Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(null);
}
Resource resource;
Stream rsrcStream = abstractFileInfo.MakeStream();
try
{
using (var rsrcReader = new LSFReader(rsrcStream))
{
resource = rsrcReader.Read();
}
}
finally
{
abstractFileInfo.ReleaseStream();
}
return(resource);
}
/// <summary>
/// Get list files for a .pak
/// </summary>
/// <param name="pak"></param>
/// <returns></returns>
public List <string> GetFileListForPak(string packagePath)
{
List <string> files = new List <string>();
try
{
using (var reader = new PackageReader(packagePath))
{
var package = reader.Read();
foreach (var fileInfo in package.Files)
{
files.Add(fileInfo.Name);
}
}
}
catch (NotAPackageException)
{
parentVM.Logger.LogString("Failed to list package contents because the package is not an Original Sin package or savegame archive");
}
catch (Exception e)
{
parentVM.Logger.LogString($"Failed to list package: {e.Message}");
parentVM.Logger.LogString($"{e.StackTrace}");
}
return(files);
}
private void loadStoryBtn_Click(object sender, EventArgs e)
{
string extension = Path.GetExtension(storyFilePath.Text)?.ToLower();
switch (extension)
{
case ".lsv":
{
var packageReader = new PackageReader(storyFilePath.Text);
Package package = packageReader.Read();
AbstractFileInfo abstractFileInfo = package.Files.FirstOrDefault(p => p.Name == "globals.lsf");
if (abstractFileInfo == null)
{
MessageBox.Show("The specified package is not a valid savegame (globals.lsf not found)", "Load Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
Resource resource;
Stream rsrcStream = abstractFileInfo.MakeStream();
try
{
using (var rsrcReader = new LSFReader(rsrcStream))
{
resource = rsrcReader.Read();
}
}
finally
{
abstractFileInfo.ReleaseStream();
}
LSLib.LS.Node storyNode = resource.Regions["Story"].Children["Story"][0];
var storyStream = new MemoryStream(storyNode.Attributes["Story"].Value as byte[] ?? throw new InvalidOperationException("Cannot proceed with null Story node"));
LoadStory(storyStream);
MessageBox.Show("Save game database loaded successfully.");
break;
}
case ".osi":
{
using (var file = new FileStream(storyFilePath.Text, FileMode.Open, FileAccess.Read))
{
LoadStory(file);
}
MessageBox.Show("Story file loaded successfully.");
break;
}
default:
{
MessageBox.Show($"Unsupported file extension: {extension}", "Load Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
break;
}
}
}
/// <summary>
/// Extract meta.lsxfrom pak
/// </summary>
/// <param name="mod"></param>
/// <returns></returns>
public string ExtractModMeta(string packagePath)
{
string wd = Dos2.ModManager.Properties.Settings.Default.WorkingDir;
string modName = Path.GetFileNameWithoutExtension(packagePath);
string destinationPath = Path.Combine(wd, $"{modName}.lsx");
string packagedPath = "meta.lsx";
try
{
using (var reader = new PackageReader(packagePath))
{
var package = reader.Read();
// Try to match by full path
var file = package.Files.Find(fileInfo => String.Compare(fileInfo.Name, packagedPath, StringComparison.OrdinalIgnoreCase) == 0);
if (file == null)
{
// Try to match by filename only
file = package.Files.Find(fileInfo => String.Compare(Path.GetFileName(fileInfo.Name), packagedPath, StringComparison.OrdinalIgnoreCase) == 0);
if (file == null)
{
parentVM.Logger.LogString($"Package doesn't contain file named '{packagedPath}'");
return("");
}
}
using (var fs = new FileStream(destinationPath, FileMode.Create, FileAccess.Write))
{
try
{
var stream = file.MakeStream();
stream.CopyTo(fs);
}
finally
{
file.ReleaseStream();
}
}
}
}
catch (NotAPackageException)
{
parentVM.Logger.LogString("Failed to list package contents because the package is not an Original Sin package or savegame archive");
}
catch (Exception e)
{
parentVM.Logger.LogString($"Failed to list package: {e.Message}");
parentVM.Logger.LogString($"{e.StackTrace}");
}
//check if outputfile was created //this should never trigger
if (!File.Exists(destinationPath))
{
return("");
}
return(destinationPath);
}
private void DiscoverPackage(string packagePath)
{
var reader = new PackageReader(packagePath);
var package = reader.Read();
foreach (var file in package.Files)
{
if (file.Name.EndsWith(".txt", StringComparison.Ordinal) && file.Name.Contains("/Story/RawFiles/Goals"))
{
var match = scriptRe.Match(file.Name);
if (match != null && match.Success)
{
AddScriptToMod(match.Groups[1].Value, match.Groups[2].Value, file);
}
}
if (file.Name.EndsWith("/Story/story_orphanqueries_ignore_local.txt", StringComparison.Ordinal))
{
var match = orphanQueryIgnoresRe.Match(file.Name);
if (match != null && match.Success)
{
GetMod(match.Groups[1].Value).OrphanQueryIgnoreList = file;
}
}
if (CollectNames)
{
if (file.Name.EndsWith(".lsf", StringComparison.Ordinal) && file.Name.Contains("/Globals/"))
{
var match = globalsRe.Match(file.Name);
if (match != null && match.Success)
{
AddGlobalsToMod(match.Groups[1].Value, match.Groups[0].Value, file);
}
}
if (file.Name.EndsWith(".lsf", StringComparison.Ordinal) && file.Name.Contains("/Levels/"))
{
var match = levelObjectsRe.Match(file.Name);
if (match != null && match.Success)
{
AddLevelObjectsToMod(match.Groups[1].Value, match.Groups[0].Value, file);
}
}
}
if (file.Name.EndsWith("/Story/RawFiles/story_header.div", StringComparison.Ordinal))
{
StoryHeaderFile = file;
}
}
}
public void Initialize()
{
try
{
pf = new PackageReader();
pf.Read("D:\\la2\\maps\\17_21.unr");
}
catch (Exception ex)
{
//Assert (no exceptions reading...)
Assert.Fail(ex.ToString());
}
}
static void Main(string[] args)
{
//Alloc
pf = new PackageReader();
pf.Read("D:\\la2\\maps\\17_21.unr");
//pf.Read("D:\\la2\\system\\lineageeffect.u");
header = new Header(pf.Bytes);
ExportTable = new ExportTable(header, pf.Bytes);
ImportTable = new ImportTable(header, pf.Bytes);
NameTable = new NameTable(header, pf.Bytes);
Property.Resolve = Resolver;
//GetAllPropertyNames();
Console.ReadKey();
}
private static void ExtractSingleFile(string packagePath, string destinationPath, string packagedPath)
{
try
{
using (var reader = new PackageReader(packagePath))
{
Package package = reader.Read();
// Try to match by full path
AbstractFileInfo file = package.Files.Find(fileInfo => string.Compare(fileInfo.Name, packagedPath, StringComparison.OrdinalIgnoreCase) == 0);
if (file == null)
{
// Try to match by filename only
file = package.Files.Find(fileInfo => string.Compare(Path.GetFileName(fileInfo.Name), packagedPath, StringComparison.OrdinalIgnoreCase) == 0);
if (file == null)
{
CommandLineLogger.LogError($"Package doesn't contain file named '{packagedPath}'");
return;
}
}
using (var fs = new FileStream(destinationPath, FileMode.Create, FileAccess.Write))
{
try
{
Stream stream = file.MakeStream();
stream.CopyTo(fs);
}
finally
{
file.ReleaseStream();
}
}
}
}
catch (NotAPackageException)
{
CommandLineLogger.LogError("Failed to list package contents because the package is not an Original Sin package or savegame archive");
}
catch (Exception e)
{
CommandLineLogger.LogFatal($"Failed to list package: {e.Message}", 2);
CommandLineLogger.LogTrace($"{e.StackTrace}");
}
}
public void PropertyCanReadEntireObject()
{
var pf1 = new PackageReader();
pf1.Read("D:\\la2\\system\\lineageeffect.u");
var header1 = new Header(pf1.Bytes);
var ExportTable1 = new ExportTable(header1, pf1.Bytes);
var ImportTable1 = new ImportTable(header1, pf1.Bytes);
var NameTable1 = new NameTable(header1, pf1.Bytes);
//Property.Resolve = Resolver;
var Exp = ExportTable1[0x793];
Assert.AreEqual("MeshEmitter0", NameTable1[Exp.NameTableRef]);
var list = Property.ReadProperties(pf1.Bytes, Exp.SerialOffset + 28);
Assert.IsNotNull(list);
Assert.AreEqual(31, list.Count);
}
public void Initialize()
{
try
{
//Alloc
pf = new PackageReader();
pf.Read("D:\\la2\\maps\\17_21.unr");
header = new Header(pf.Bytes);
ExportTable = new ExportTable(header, pf.Bytes);
ImportTable = new ImportTable(header, pf.Bytes);
NameTable = new NameTable(header, pf.Bytes);
Property.Resolve = Resolver;
}
catch (Exception ex)
{
//Assert (no exceptions reading...)
Assert.Fail(ex.ToString());
}
}
public void Run()
{
ReportProgress(0, "Reading package ...");
using (var packageReader = new PackageReader(SaveFilePath))
{
SavePackage = packageReader.Read();
AbstractFileInfo abstractFileInfo = SavePackage.Files.FirstOrDefault(p => p.Name == "globals.lsf");
if (abstractFileInfo == null)
{
MessageBox.Show("The specified package is not a valid savegame (globals.lsf not found)", "Load Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
RunTasks();
MessageBox.Show($"Savegame dumped to {DataDumpPath}.");
}
}
private void LoadData()
{
_reader = new PackageReader();
_reader.Read(PathToFile);
PackageViewModel = new PackageViewModel(_reader);
MetadataViewModel = new MetadataViewModel(_reader);
ManifestViewModel = new ManifestViewModel(_reader);
RequiresViewModel = new RequiresViewModel(_reader);
DefineViewModel = new DefineViewModel(_reader);
SigningViewModel = new SigningViewModel(_reader);
LicenseViewModel = new LicenseViewModel(_reader);
CompatibilityPolicy = new CompatibilityPolicyViewModel(_reader);
ApplicationRoleViewModel = new ApplicationRoleViewModel(_reader);
AssemblyRoleViewModel = new AssemblyRoleViewModel(_reader);
FilesViewModel = new FilesViewModel(_reader);
//PackageCompositionViewModel = new PackageCompositionViewModel(_reader);
//_allViewModels.Add(PackageViewModel);
}
private void LoadData()
{
_dictionaryHistory = new Dictionary<string, List<string>>();
PackageReader reader = new PackageReader();
reader.Read(PathToFile);
_ruleNames = reader.Rules;
_roleNames = reader.Roles;
CreateModels(reader);
IEnumerable<string> asd = reader.GetRulesPropertyValues("files", "include");
List<string> sfasfa = asd.ToList();
string dwdw = asd.First();
reader.ReadFilesParameters();
string sfasffa = reader.GetRolesPropertyValueByName("faux-pax", "downloadsprocmon.chm");
}
private void SaveSavegameDatabase()
{
var packageReader = new PackageReader(storyFilePath.Text);
Package package = packageReader.Read();
AbstractFileInfo globalsLsf = package.Files.FirstOrDefault(p => p.Name == "globals.lsf");
if (globalsLsf == null)
{
MessageBox.Show("The specified package is not a valid savegame (globals.lsf not found)", "Load Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
// Load globals.lsf
Resource resource;
Stream rsrcStream = globalsLsf.MakeStream();
try
{
using (var rsrcReader = new LSFReader(rsrcStream))
{
resource = rsrcReader.Read();
}
}
finally
{
globalsLsf.ReleaseStream();
}
// Save story resource and pack into the Story.Story attribute in globals.lsf
using (var storyStream = new MemoryStream())
{
var storyWriter = new StoryWriter();
storyWriter.Write(storyStream, _story);
LSLib.LS.Node storyNode = resource.Regions["Story"].Children["Story"][0];
storyNode.Attributes["Story"].Value = storyStream.ToArray();
}
// Save globals.lsf
var rewrittenStream = new MemoryStream();
// TODO: Resave using original version
var rsrcWriter = new LSFWriter(rewrittenStream, FileVersion.CurrentVersion);
rsrcWriter.Write(resource);
rewrittenStream.Seek(0, SeekOrigin.Begin);
// Re-package global.lsf
var rewrittenPackage = new Package();
StreamFileInfo globalsRepacked = StreamFileInfo.CreateFromStream(rewrittenStream, "globals.lsf");
rewrittenPackage.Files.Add(globalsRepacked);
List <AbstractFileInfo> files = package.Files.Where(x => x.Name != "globals.lsf").ToList();
rewrittenPackage.Files.AddRange(files);
using (var packageWriter = new PackageWriter(rewrittenPackage, $"{storyFilePath.Text}.tmp"))
{
// TODO: Resave using original version and flags
packageWriter.Version = PackageVersion.V13;
packageWriter.Compression = CompressionMethod.Zlib;
packageWriter.CompressionLevel = CompressionLevel.DefaultCompression;
packageWriter.Write();
}
rewrittenStream.Dispose();
packageReader.Dispose();
// Create a backup of the original .lsf
string backupPath = $"{storyFilePath.Text}.backup";
if (!File.Exists(backupPath))
{
File.Move(storyFilePath.Text, backupPath);
}
else
{
File.Delete(storyFilePath.Text);
}
// Replace original savegame with new one
File.Move($"{storyFilePath.Text}.tmp", storyFilePath.Text);
}
public static bool RenameSave(string pathToSave, string newName)
{
try
{
string baseOldName = Path.GetFileNameWithoutExtension(pathToSave);
string baseNewName = Path.GetFileNameWithoutExtension(newName);
string output = Path.ChangeExtension(Path.Combine(Path.GetDirectoryName(pathToSave), newName), ".lsv");
using (var reader = new PackageReader(pathToSave))
{
Package package = reader.Read();
AbstractFileInfo saveScreenshotImage = package.Files.FirstOrDefault(p => p.Name.EndsWith(".png"));
if (saveScreenshotImage != null)
{
saveScreenshotImage.Name = saveScreenshotImage.Name.Replace(Path.GetFileNameWithoutExtension(saveScreenshotImage.Name), baseNewName);
Trace.WriteLine($"Renamed internal screenshot '{saveScreenshotImage.Name}' in '{output}'.");
}
// Edit the saved date in the meta.lsf to avoid "corruption" messages
/*
* AbstractFileInfo metaFile = package.Files.FirstOrDefault(p => p.Name == "meta.lsf");
* if (metaFile != null)
* {
* Resource resource;
* System.IO.MemoryStream ms = null;
* System.IO.Stream rsrcStream = null;
* try
* {
* rsrcStream = metaFile.MakeStream();
* using (var rsrcReader = new LSFReader(rsrcStream))
* {
* resource = rsrcReader.Read();
*
* if (resource != null)
* {
* var saveTimeNode = resource.FindNode("SaveTime");
*
* if (saveTimeNode != null)
* {
* NodeAttribute yearAtt = null;
* NodeAttribute monthAtt = null;
* NodeAttribute dayAtt = null;
* NodeAttribute hoursAtt = null;
* NodeAttribute minutesAtt = null;
* NodeAttribute secondsAtt = null;
* NodeAttribute millisecondsAtt = null;
*
* saveTimeNode.Attributes.TryGetValue("Year", out yearAtt);
* saveTimeNode.Attributes.TryGetValue("Month", out monthAtt);
* saveTimeNode.Attributes.TryGetValue("Day", out dayAtt);
* saveTimeNode.Attributes.TryGetValue("Hours", out hoursAtt);
* saveTimeNode.Attributes.TryGetValue("Minutes", out minutesAtt);
* saveTimeNode.Attributes.TryGetValue("Seconds", out secondsAtt);
* saveTimeNode.Attributes.TryGetValue("Milliseconds", out millisecondsAtt);
*
* var time = DateTime.Now;
*
* Trace.WriteLine($"Year: {yearAtt.Type}");
* Trace.WriteLine($"Month: {monthAtt.Type}");
* Trace.WriteLine($"Day: {dayAtt.Type}");
* Trace.WriteLine($"Hours: {hoursAtt.Type}");
* Trace.WriteLine($"Minutes: {minutesAtt.Type}");
* Trace.WriteLine($"Seconds: {secondsAtt.Type}");
* Trace.WriteLine($"Milliseconds: {millisecondsAtt.Type}");
*
* yearAtt.Value = (Byte)time.Year;
* monthAtt.Value = (Byte)time.Month;
* dayAtt.Value = (Byte)time.Day;
* hoursAtt.Value = (Byte)time.Hour;
* minutesAtt.Value = (Byte)time.Minute;
* secondsAtt.Value = (Byte)time.Second;
* millisecondsAtt.Value = (UInt16)time.Millisecond;
*
* Trace.WriteLine($"Updated SaveTime in save's meta.lsf.");
* }
* else
* {
* Trace.WriteLine($"Couldn't find SaveTime node '{String.Join(";", resource.Regions.Values.First().Children.Keys)}'.");
* }
*
* ms = new System.IO.MemoryStream(new byte[4096], true);
* var rscrWriter = new LSFWriter(ms, FileVersion.CurrentVersion);
* rscrWriter.Write(resource);
* ms.Position = 0;
* var data = ms.ToArray();
*
* if (!ms.CanRead) Trace.WriteLine("MemoryStream is not readable!");
* if(!ms.CanWrite) Trace.WriteLine("MemoryStream is not writable!");
* if(!rsrcStream.CanRead) Trace.WriteLine("rsrcStream is not readable!");
* if(!rsrcStream.CanWrite) Trace.WriteLine("rsrcStream is not writable!");
*
* rsrcStream.Write(data, 0, data.Length);
* ms.Close();
* }
* }
* }
* finally
* {
* if (metaFile != null) metaFile.ReleaseStream();
* if (ms != null) ms.Dispose();
* if (rsrcStream != null) rsrcStream.Dispose();
* }
* }
*/
using (var writer = new PackageWriter(package, output))
{
writer.Version = Package.CurrentVersion;
writer.Compression = LSLib.LS.Enums.CompressionMethod.Zlib;
writer.CompressionLevel = CompressionLevel.DefaultCompression;
writer.Write();
}
File.SetLastWriteTime(output, File.GetLastWriteTime(pathToSave));
File.SetLastAccessTime(output, File.GetLastAccessTime(pathToSave));
return(true);
}
}
catch (Exception ex)
{
Trace.WriteLine($"Failed to rename save: {ex.ToString()}");
}
return(false);
}
