|
public static RestorePatchedFiles ( AppInfo appInfo, IEnumerable |
||
| appInfo | AppInfo | |
| seq | IEnumerable |
|
| return | void | |
public async Task <XmlHistory> PatchAsync(LaunchType launchType)
{
var history = new XmlHistory();
history.Success = false;
var totalProgress = new ProgressObject();
var logForm = new LogForm(totalProgress);
logForm.InvokeIfRequired(() => logForm.Show());
try
{
List <PatchGroup> patches = PatchManager.SaveInstructions(ref history);
await Task.Run(() => PatchManager.ApplyInstructions(launchType, patches, totalProgress)).ConfigureAwait(false);
history.Success = true;
}
catch (Exception exception)
{
Logger.Error(exception, "Patching failed because instructions cannot be applied.");
}
if (!history.Success)
{
PatchingHelper.RestorePatchedFiles(AppContextManager.Context.Value, history.Files);
}
logForm.InvokeIfRequired(() => CloseForm(logForm));
return(history);
}
public async Task LaunchTestRunAsync(LaunchType launchType = LaunchType.Test)
{
StartUnlockDialog();
SetState(LaunchManagerState.IsPatching);
XmlHistory history = await this.PatchAsync(launchType).ConfigureAwait(false);
SetState(LaunchManagerState.Idle);
PatchingHelper.RestorePatchedFiles(AppContextManager.Context.Value, history.Files);
if (!PreferencesManager.OpenLogAfterPatch)
{
return;
}
try
{
string logPath = LogManager.Logs.First(kvp => kvp.Key == "PatchManager").Value;
TryOpenTextFile(logPath);
}
catch (Exception exception)
{
Logger.Error(exception, "Cannot open log file after test run");
}
}
public async Task LaunchTestRunAsync(LaunchType launchType = LaunchType.Test)
{
MainWindow.Enabled = false;
new Thread(o => AskUnlockGUI()).Start();
State.Value = LaunchManagerState.IsPatching;
XmlHistory history = await this.PatchAsync(launchType).ConfigureAwait(false);
State.Value = LaunchManagerState.Idle;
PatchingHelper.RestorePatchedFiles(AppContextManager.Context.Value, history.Files);
if (PreferencesManager.OpenLogAfterPatch)
{
try
{
string logPath = LogManager.Logs.First(kvp => kvp.Key == "PatchManager").Value;
TryOpenTextFile(logPath);
}
catch (Exception exception)
{
Logger.Error(exception, "Cannot open log file after test run");
}
}
}
public static void RestorePatchedFiles()
{
if (History != null)
{
Logger.Debug("Trying to restore patched files because we have History...");
PatchingHelper.RestorePatchedFiles(AppContextManager.Context.Value, History.Files);
}
}
public async Task <XmlHistory> Command_Patch()
{
State.Value = LaunchManagerState.IsPatching;
var history = new XmlHistory
{
Success = false
};
try
{
var progObj = new ProgressObject();
using (var logForm = new LogForm(progObj)
{
Icon = _home.Icon
})
{
logForm.Show();
try
{
var patches = GroupPatches(Instructions).ToList();
history.Files = patches.Select(XmlFileHistory.FromInstrGroup).ToList();
_historySerializer.Serialize(history, _pathHistoryXml);
await Task.Run(() => ApplyInstructions(patches, progObj));
history.Success = true;
}
catch (PatchingProcessException ex)
{
Command_Display_Patching_Error(ex);
}
if (!history.Success)
{
PatchingHelper.RestorePatchedFiles(AppInfo, history.Files);
}
logForm.Close();
}
}
catch (Exception ex)
{
Command_Display_Error("Patch the game", ex: ex);
}
finally
{
State.Value = LaunchManagerState.Idle;
if (Preferences.OpenLogAfterPatch)
{
Process.Start(_pathLogFile);
}
}
return(history);
}
public async void Command_Launch_Modded()
{
Action <IBindable <LaunchManagerState> > p = null;
var history = await Command_Patch();
p = v => {
if (v.Value == LaunchManagerState.Idle)
{
PatchingHelper.RestorePatchedFiles(AppInfo, history.Files);
State.HasChanged -= p;
}
};
State.HasChanged += p;
Command_Launch();
}
public async void Command_TestRun()
{
var history = await Command_Patch();
PatchingHelper.RestorePatchedFiles(AppInfo, history.Files);
}
public LaunchManager()
{
//the following is needed on linux... the current directory must be the Mono executable, which is bad.
Environment.CurrentDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
try {
FormIcon = Icon.FromHandle(Resources.IconSmall.GetHicon());
if (File.Exists(_pathLogFile))
{
File.Delete(_pathLogFile);
}
XmlPreferences prefs = new XmlPreferences();
try {
prefs = _prefsSerializer.Deserialize(_pathPrefsFile, new XmlPreferences());
}
catch (Exception ex) {
Command_Display_Error("Read preferences file", _pathPrefsFile, ex, "Special preferences will be reset");
}
Preferences = prefs;
Logger =
new LoggerConfiguration().WriteTo.File(_pathLogFile, LogEventLevel.Verbose).MinimumLevel.Is(Preferences.MinimumEventLevel).CreateLogger();
AppInfoFactory gameInfoFactory;
gameInfoFactory = !File.Exists(_pathGameInfoAssembly) ? null : PatchingHelper.LoadAppInfoFactory(_pathGameInfoAssembly);
var settings = new XmlSettings();
var history = new XmlHistory();
;
try {
history = _historySerializer.Deserialize(_pathHistoryXml, new XmlHistory());
}
catch (Exception ex) {
Command_Display_Error("Load patching history", _pathHistoryXml, ex,
"If the launcher was terminated unexpectedly last time, it may not be able to recover.");
}
try {
settings = _settingsSerializer.Deserialize(_pathSettings, new XmlSettings());
}
catch (Exception ex) {
Command_Display_Error("Read settings file", _pathSettings, ex, "Patch list and other settings will be reset.");
}
string folderDialogReason = null;
if (settings.BaseFolder == null)
{
folderDialogReason = "(no game folder has been specified)";
}
else if (!Directory.Exists(settings.BaseFolder))
{
folderDialogReason = "(the previous game folder does not exist)";
}
if (folderDialogReason != null)
{
if (!Command_SetGameFolder_Dialog(folderDialogReason))
{
Command_ExitApplication();
}
}
else
{
BaseFolder = settings.BaseFolder;
}
_home = new guiHome(this)
{
Icon = FormIcon
};
var defaultAppInfo = new AppInfo()
{
AppName = "No AppInfo.dll",
};
AppInfo = gameInfoFactory?.CreateInfo(new DirectoryInfo(BaseFolder)) ?? defaultAppInfo;
AppInfo.AppVersion = AppInfo.AppVersion ?? "version??";
var icon = TryOpenIcon(AppInfo.IconLocation) ?? _home.Icon.ToBitmap();
ProgramIcon = icon;
Instructions = new DisposingBindingList <PatchInstruction>();
var instructions = new List <XmlInstruction>();
foreach (var xmlPatch in settings.Instructions)
{
try {
Command_Direct_AddPatch(xmlPatch.PatchPath, xmlPatch.IsEnabled);
}
catch {
instructions.Add(xmlPatch);
}
}
var patchList = instructions.Select(x => x.PatchPath).Join(Environment.NewLine);
if (patchList.Length > 0)
{
Command_Display_Error("Load patches on startup.", patchList);
}
try {
PatchingHelper.RestorePatchedFiles(AppInfo, history.Files);
}
catch (Exception ex) {
Command_Display_Error("Restore files", ex: ex);
}
//File.Delete(_pathHistoryXml);
_home.Closed += (sender, args) => Command_ExitApplication();
_icon = new NotifyIcon {
Icon = FormIcon,
Visible = false,
Text = "Patchwork Launcher",
ContextMenu = new ContextMenu {
MenuItems =
{
new MenuItem("Quit", (o, e) => Command_ExitApplication())
}
}
};
File.Delete(_pathHistoryXml);
}
catch (Exception ex) {
Command_Display_Error("Launch the application", ex: ex, message: "The application will now exit.");
Command_ExitApplication();
}
}
