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);
}
}
private Resource LoadPackagedResource(string path)
{
AbstractFileInfo fileInfo = SavePackage.Files.FirstOrDefault(p => p.Name == path);
if (fileInfo == null)
{
throw new ArgumentException($"Could not locate file in package: '{path}");
}
Resource resource;
Stream rsrcStream = fileInfo.MakeStream();
try
{
using (var rsrcReader = new LSFReader(rsrcStream))
{
resource = rsrcReader.Read();
}
}
finally
{
fileInfo.ReleaseStream();
}
return(resource);
}
public void GetItemsSize(AbstractFileInfo[] files)
{
long total = 0;
try
{
for (int i = 0; i < files.Length; i++)
{
AbstractFileInfo f = files[i];
if (f.IsDirectory)
{
total += _client.GetDirectorySize(f.FullName, true);
}
else
{
total += f.Length;
}
}
_view.ShowMessage(string.Format("Total size: {0}", Util.FormatSize(total)));
}
catch (Exception exc)
{
HandleException(exc);
}
}
private void DiscoverModDirectory(string modName, string modPath)
{
DiscoverModGoals(modName, modPath);
if (CollectNames)
{
DiscoverModGlobals(modName, modPath);
DiscoverModLevelObjects(modName, modPath);
}
if (!LoadPackages)
{
var headerPath = modPath + @"\Story\RawFiles\story_header.div";
if (File.Exists(headerPath))
{
var fileInfo = new FilesystemFileInfo
{
FilesystemPath = headerPath,
Name = headerPath
};
StoryHeaderFile = fileInfo;
}
}
var orphanQueryIgnoresPath = modPath + @"\Story\story_orphanqueries_ignore_local.txt";
if (File.Exists(orphanQueryIgnoresPath))
{
var fileInfo = new FilesystemFileInfo
{
FilesystemPath = orphanQueryIgnoresPath,
Name = orphanQueryIgnoresPath
};
GetMod(modName).OrphanQueryIgnoreList = fileInfo;
}
}
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);
}
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;
}
}
}
public static bool IsModMetaFile(string pakName, AbstractFileInfo f)
{
if (Path.GetFileName(f.Name).Equals("meta.lsx", StringComparison.OrdinalIgnoreCase))
{
return(modMetaPattern.IsMatch(f.Name));
}
return(false);
}
public override int OnCompare(AbstractFileInfo x, AbstractFileInfo y, string xtext, string ytext)
{
if (x.Length == y.Length)
{
return(0);
}
return(x.Length > y.Length ? 1 : -1);
}
public void ListFiles(List <ListItemInfo> viewList, ListView listView, bool local)
{
ListViewItem item;
// Clear the list.
listView.Items.Clear();
for (int i = 0; i < viewList.Count; i++)
{
ListItemInfo listitem = viewList[i];
AbstractFileInfo f = listitem.FileInfo;
if (f.IsDirectory)
{
item = listView.Items.Add(f.Name, _folderIconIndex);
item.SubItems.Add("");
}
else
{
if (listitem.LinkedFile != null)
{
item = listView.Items.Add(f.Name, listitem.LinkedFile.IsDirectory ? FolderLinkImageIndex : SymlinkImageIndex);
}
else
{
item = listView.Items.Add(f.Name, SetFileIcon(Path.Combine(txtLocalDir.Text, f.Name)));
}
item.SubItems.Add(Util.FormatSize(f.Length));
}
if (f.LastWriteTime != DateTime.MinValue)
{
item.SubItems.Add(f.LastWriteTime.ToString());
}
item.SubItems.Add(listitem.Permissions);
item.Tag = listitem;
}
if (local)
{
UpdateLocalListViewSorter();
}
else
{
UpdateRemoteListViewSorter();
}
if (viewList.Count > 0)
{
listView.Items[0].Selected = true;
}
}
public string GetPermissionsString(AbstractFileInfo f)
{
if (((FtpFileInfo)f).System == FtpFileOs.Unix)
{
return(ToPermissions(((FtpFileInfo)f).Permissions));
}
else
{
return("-");
}
}
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;
}
}
}
/// <summary>
/// Resumes download the specified files.
/// </summary>
/// <param name="files">Files to resume download.</param>
public void DoRemoteResumeDownload(AbstractFileInfo[] files)
{
if (files == null)
{
return;
}
EnableProgress(true);
try
{
for (int i = 0; i < files.Length; i++)
{
if (_aborting)
{
break;
}
AbstractFileInfo remoteFile = files[i];
if (remoteFile.IsFile)
{
// Download a single file.
long result = _client.ResumeDownloadFile(remoteFile.Name, Path.Combine(_currentLocalDirectory, remoteFile.Name));
if (files.Length == 1)
{
if (result == -1)
{
_view.ShowMessage("Local file size is greater than the remote file size");
}
else if (result == 0)
{
_view.ShowMessage("Local file size is equal to the remote file size");
}
}
}
}
}
catch (Exception exc)
{
if (!HandleException(exc))
{
return;
}
}
EnableProgress(false);
RefreshLocalList();
}
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 DoLocalResumeUpload(AbstractFileInfo[] files)
{
EnableProgress(true);
try
{
for (int i = 0; i < files.Length; i++)
{
if (_aborting)
{
break;
}
AbstractFileInfo localFile = files[i];
if (localFile.IsFile)
{
// Upload a single file.
long result = _client.ResumeUploadFile(localFile.FullName, localFile.Name);
if (files.Length == 1)
{
if (result == -1)
{
_view.ShowMessage("Remote file size is greater than the local file size");
}
else if (result == 0)
{
_view.ShowMessage("Remote file size is equal to the local file size");
}
}
}
}
}
catch (Exception exc)
{
if (!HandleException(exc))
{
return;
}
}
EnableProgress(false);
RefreshRemoteList();
}
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}.");
}
}
public bool Compile(string outputPath, string debugInfoPath, List <string> mods)
{
Logger.CompilationStarted();
HasErrors = false;
Compiler.Game = Game;
Compiler.AllowTypeCoercion = AllowTypeCoercion;
if (mods.Count > 0)
{
Logger.TaskStarted("Discovering module files");
var visitor = new ModPathVisitor(Mods)
{
Game = Game,
CollectStoryGoals = true,
CollectGlobals = CheckGameObjects,
CollectLevels = CheckGameObjects,
LoadPackages = LoadPackages
};
visitor.Discover(GameDataPath);
Logger.TaskFinished();
Logger.TaskStarted("Loading module files");
if (CheckGameObjects)
{
var nullGameObject = new GameObjectInfo
{
Name = "NULL_00000000-0000-0000-0000-000000000000",
Type = Compiler.Context.LookupType("GUIDSTRING")
};
Compiler.Context.GameObjects.Add("00000000-0000-0000-0000-000000000000", nullGameObject);
}
foreach (var modName in mods)
{
LoadMod(modName);
}
AbstractFileInfo storyHeaderFile = null;
AbstractFileInfo typeCoercionWhitelistFile = null;
var modsSearchPath = mods.ToList();
modsSearchPath.Reverse();
foreach (var modName in modsSearchPath)
{
if (storyHeaderFile == null && Mods.Mods[modName].StoryHeaderFile != null)
{
storyHeaderFile = Mods.Mods[modName].StoryHeaderFile;
}
if (typeCoercionWhitelistFile == null && Mods.Mods[modName].TypeCoercionWhitelistFile != null)
{
typeCoercionWhitelistFile = Mods.Mods[modName].TypeCoercionWhitelistFile;
}
}
if (storyHeaderFile != null)
{
var storyStream = storyHeaderFile.MakeStream();
LoadStoryHeaders(storyStream);
storyHeaderFile.ReleaseStream();
}
else
{
Logger.CompilationDiagnostic(new Diagnostic(null, MessageLevel.Error, "X00", "Unable to locate story header file (story_header.div)"));
HasErrors = true;
}
if (typeCoercionWhitelistFile != null)
{
var typeCoercionStream = typeCoercionWhitelistFile.MakeStream();
LoadTypeCoercionWhitelist(typeCoercionStream);
typeCoercionWhitelistFile.ReleaseStream();
Compiler.TypeCoercionWhitelist = TypeCoercionWhitelist;
}
Logger.TaskFinished();
}
if (CheckGameObjects)
{
Logger.TaskStarted("Loading game objects");
LoadGlobals();
Logger.TaskFinished();
}
else
{
Compiler.Context.Log.WarningSwitches[DiagnosticCode.UnresolvedGameObjectName] = false;
}
if (OsiExtender)
{
Logger.TaskStarted("Precompiling scripts");
ParallelPreprocess();
Logger.TaskFinished();
}
var asts = new Dictionary <String, ASTGoal>();
var goalLoader = new IRGenerator(Compiler.Context);
Logger.TaskStarted("Generating IR");
var orderedGoalAsts = ParallelBuildIR();
foreach (var goal in orderedGoalAsts)
{
Compiler.AddGoal(goal);
}
Logger.TaskFinished();
bool updated;
var iter = 1;
do
{
Logger.TaskStarted($"Propagating rule types {iter}");
updated = Compiler.PropagateRuleTypes();
Logger.TaskFinished();
if (iter++ > 10)
{
Compiler.Context.Log.Error(null, DiagnosticCode.InternalError,
"Maximal number of rule propagation retries exceeded");
break;
}
} while (updated);
Logger.TaskStarted("Checking for unresolved references");
Compiler.VerifyIR();
Logger.TaskFinished();
foreach (var message in Compiler.Context.Log.Log)
{
Logger.CompilationDiagnostic(message);
if (message.Level == MessageLevel.Error)
{
HasErrors = true;
}
}
if (!HasErrors && !CheckOnly)
{
Logger.TaskStarted("Generating story nodes");
var emitter = new StoryEmitter(Compiler.Context);
if (debugInfoPath != null)
{
emitter.EnableDebugInfo();
}
var story = emitter.EmitStory();
Logger.TaskFinished();
Logger.TaskStarted("Saving story binary");
using (var file = new FileStream(outputPath, FileMode.Create, FileAccess.Write))
{
var writer = new StoryWriter();
writer.Write(file, story);
}
Logger.TaskFinished();
if (debugInfoPath != null)
{
Logger.TaskStarted("Saving debug info");
using (var file = new FileStream(debugInfoPath, FileMode.Create, FileAccess.Write))
{
var writer = new DebugInfoSaver();
writer.Save(file, emitter.DebugInfo);
}
Logger.TaskFinished();
}
}
Logger.CompilationFinished(!HasErrors);
return(!HasErrors);
}
private void AddScriptToMod(string modName, string scriptName, AbstractFileInfo file)
{
GetMod(modName).Scripts[scriptName] = file;
}
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);
}
public override int OnCompare(AbstractFileInfo x, AbstractFileInfo y, string xtext, string ytext)
{
return(DateTime.Compare(x.LastWriteTime, y.LastWriteTime));
}
public ListItemInfo(AbstractFileInfo info)
{
FileInfo = info;
}
private void ListFiles(FileInfoCollection files, bool rootDir, bool local)
{
List <ListItemInfo> viewList = new List <ListItemInfo>();
ListItemInfo item;
// Add directories into the list first.
for (int i = 0; i < files.Count; i++)
{
AbstractFileInfo f = files[i];
if (f.IsDirectory)
{
if (f.Name != "." && f.Name != "..")
{
item = new ListItemInfo();
item.FileInfo = f;
if (!local)
{
item.Permissions = _clientPlugin.GetPermissionsString(f);
}
viewList.Add(item);
}
}
else if (f.IsSymlink) // Add symlinks.
{
item = new ListItemInfo();
item.FileInfo = f;
item.LinkedFile = _client.GetFileInfo(f.SymlinkPath);
item.Permissions = _clientPlugin.GetPermissionsString(f);
viewList.Add(item);
}
else //Add Files.
{
item = new ListItemInfo();
item.FileInfo = f;
if (!local)
{
item.Permissions = _clientPlugin.GetPermissionsString(f);
}
viewList.Add(item);
}
}
if (!rootDir)
{
// Add Cdup list item.
item = new ListItemInfo();
if (local)
{
item.FileInfo = DiskFileSystem.Default.CreateFileInfo("..", FileAttributes.Directory, -1, DateTime.MinValue);
}
else
{
item.FileInfo = _client.CreateFileInfo("..", FileAttributes.Directory, -1, DateTime.MinValue);
}
viewList.Add(item);
}
if (local)
{
_view.ListLocalFiles(viewList);
}
else
{
_view.ListRemoteFiles(viewList);
}
}
private void AddLevelObjectsToMod(string modName, string path, AbstractFileInfo file)
{
GetMod(modName).LevelObjects[path] = file;
}
public override int OnCompare(AbstractFileInfo x, AbstractFileInfo y, string xtext, string ytext)
{
return(string.Compare(xtext, ytext, true));
}
public override int OnCompare(AbstractFileInfo x, AbstractFileInfo y, string xtext, string ytext)
{
return(((FtpFileInfo)x).Permissions - ((FtpFileInfo)y).Permissions);
}
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 string GetPermissionsString(AbstractFileInfo f)
{
return(ToPermissions(((SftpFileInfo)f).Permissions));
}
private void PackageProgressUpdate(string status, long numerator, long denominator, AbstractFileInfo file)
{
if (file != null)
{
// Throttle the progress displays to 10 updates per second to prevent UI
// updates from slowing down the compression/decompression process
if (_displayTimer == null)
{
_displayTimer = new Stopwatch();
_displayTimer.Start();
}
else if (_displayTimer.ElapsedMilliseconds < 100)
{
return;
}
else
{
_displayTimer.Restart();
}
}
packageProgressLabel.Text = status;
if (denominator == 0)
{
packageProgress.Value = 0;
}
else
{
packageProgress.Value = (int)(numerator * 100 / denominator);
}
Application.DoEvents();
}
private void AddGlobalsToMod(string modName, string path, AbstractFileInfo file)
{
GetMod(modName).Globals[path] = file;
}
public abstract int OnCompare(AbstractFileInfo x, AbstractFileInfo y, string xtext, string ytext);