internal static async Task RestoreFM(FanMission fm)
{
if (!GameIsKnownAndSupported(fm.Game))
{
Log("Game type is unknown or unsupported (" + fm.Archive + ", " + fm.InstalledDir + ", " + fm.Game + ")", stackTrace: true);
return;
}
bool restoreSavesAndScreensOnly = Config.BackupFMData == BackupFMData.SavesAndScreensOnly &&
(fm.Game != Game.Thief3 || !Config.T3UseCentralSaves);
bool fmIsT3 = fm.Game == Game.Thief3;
await Task.Run(() =>
{
(string Name, bool DarkLoader)fileToUse = ("", false);
#region DarkLoader
string dlBakDir = Path.Combine(Config.FMsBackupPath, Paths.DarkLoaderSaveBakDir);
if (Directory.Exists(dlBakDir))
{
foreach (string f in FastIO.GetFilesTopOnly(dlBakDir, "*.zip"))
{
string fn = f.GetFileNameFast();
int index = fn.LastIndexOf("_saves.zip", StringComparison.OrdinalIgnoreCase);
if (index == -1)
{
continue;
}
string an = fn.Substring(0, index).Trim();
// Account for the fact that DarkLoader trims archive names for save backup zips
// Note: I guess it doesn't?! The code heavily implies it does. Still, it works either
// way, so whatever.
if (!an.IsEmpty() && an.PathEqualsI(fm.Archive.RemoveExtension().Trim()))
{
fileToUse = (f, true);
break;
}
}
}
#endregion
#region AngelLoader / FMSel / NewDarkLoader
if (fileToUse.Name.IsEmpty())
{
var bakFiles = new List <FileInfo>();
void AddBakFilesFrom(string path)
{
for (int i = 0; i < 2; i++)
{
string fNoExt = i == 0 ? fm.Archive.RemoveExtension() : fm.InstalledDir;
string bakFile = Path.Combine(path, fNoExt + Paths.FMBackupSuffix);
if (File.Exists(bakFile))
{
bakFiles.Add(new FileInfo(bakFile));
}
}
}
// Our backup path, separate to avoid creating any more ambiguity
AddBakFilesFrom(Config.FMsBackupPath);
// If ArchiveName.bak and InstalledName.bak files both exist, use the newest of the two
fileToUse.Name = bakFiles.Count == 1
? bakFiles[0].FullName
: bakFiles.Count > 1
? bakFiles.OrderByDescending(x => x.LastWriteTime).ToList()[0].FullName
: "";
bakFiles.Clear();
// Use file from our bak dir if it exists, otherwise use the newest file from all archive dirs
// (for automatic use of FMSel/NDL saves)
if (fileToUse.Name.IsEmpty())
{
foreach (string path in FMArchives.GetFMArchivePaths())
{
AddBakFilesFrom(path);
}
if (bakFiles.Count == 0)
{
return;
}
// Use the newest of all files found in all archive dirs
fileToUse.Name = bakFiles.OrderByDescending(x => x.LastWriteTime).ToList()[0].FullName;
}
}
#endregion
var fileExcludes = new List <string>();
//var dirExcludes = new List<string>();
string thisFMInstallsBasePath = Config.GetFMInstallPathUnsafe(fm.Game);
string fmInstalledPath = Path.Combine(thisFMInstallsBasePath, fm.InstalledDir);
using (var archive = GetZipArchiveCharEnc(fileToUse.Name))
{
int filesCount = archive.Entries.Count;
if (fileToUse.DarkLoader)
{
for (int i = 0; i < filesCount; i++)
{
var entry = archive.Entries[i];
string fn = entry.FullName;
if (!fn.ContainsDirSep())
{
Directory.CreateDirectory(Path.Combine(fmInstalledPath, _darkSavesDir));
entry.ExtractToFile(Path.Combine(fmInstalledPath, _darkSavesDir, fn), overwrite: true);
}
else if (fm.Game == Game.SS2 && (_ss2SaveDirsInZipRegex.IsMatch(fn) || fn.PathStartsWithI(_ss2CurrentDirS)))
{
Directory.CreateDirectory(Path.Combine(fmInstalledPath, fn.Substring(0, fn.LastIndexOfDirSep())));
entry.ExtractToFile(Path.Combine(fmInstalledPath, fn), overwrite: true);
}
}
}
else
{
string savesDirS = fmIsT3 ? _t3SavesDirS : _darkSavesDirS;
if (restoreSavesAndScreensOnly)
{
for (int i = 0; i < filesCount; i++)
{
var entry = archive.Entries[i];
string fn = entry.FullName;
if (fn.Length > 0 && !fn[fn.Length - 1].IsDirSep() &&
(fn.PathStartsWithI(savesDirS) ||
fn.PathStartsWithI(_darkNetSavesDirS) ||
fn.PathStartsWithI(_screensDirS) ||
(fm.Game == Game.SS2 &&
(_ss2SaveDirsInZipRegex.IsMatch(fn) || fn.PathStartsWithI(_ss2CurrentDirS)))))
{
Directory.CreateDirectory(Path.Combine(fmInstalledPath, fn.Substring(0, fn.LastIndexOfDirSep())));
entry.ExtractToFile(Path.Combine(fmInstalledPath, fn), overwrite: true);
}
}
}
else
{
var fmSelInf = archive.GetEntry(Paths.FMSelInf);
// Cap the length, cause... well, nobody's going to put a 500MB binary file named
// fmsel.inf, but hey...
// Null check required because GetEntry() can return null
if (fmSelInf?.Length < ByteSize.MB * 10)
{
using var eo = fmSelInf.Open();
using var sr = new StreamReader(eo);
string?line;
while ((line = sr.ReadLine()) != null)
{
bool startsWithRemoveFile = line.StartsWithFast_NoNullChecks(_removeFileEq);
bool startsWithRemoveDir = false;
if (!startsWithRemoveFile)
{
startsWithRemoveDir = line.StartsWithFast_NoNullChecks(_removeDirEq);
}
if (!startsWithRemoveFile && !startsWithRemoveDir)
{
continue;
}
string val = line.Substring(startsWithRemoveFile ? 11 : 10).Trim();
if (!val.PathStartsWithI(savesDirS) &&
!val.PathStartsWithI(_darkNetSavesDirS) &&
!val.PathStartsWithI(_screensDirS) &&
(fm.Game != Game.SS2 ||
(!_ss2SaveDirsInZipRegex.IsMatch(val) && !val.PathStartsWithI(_ss2CurrentDirS))) &&
!val.PathEqualsI(Paths.FMSelInf) &&
!val.PathEqualsI(_startMisSav) &&
// Reject malformed and/or maliciously formed paths - we're going to
// delete these files, and we don't want to delete anything outside
// the FM folder
!val.StartsWithDirSep() &&
!val.Contains(':') &&
// @DIRSEP: Critical: Check both / and \ here because we have no dirsep-agnostic string.Contains()
!val.Contains("./") &&
!val.Contains(".\\"))
{
if (startsWithRemoveFile)
{
fileExcludes.Add(val);
}
//else
//{
// dirExcludes.Add(val);
//}
}
}
}
for (int i = 0; i < filesCount; i++)
{
var f = archive.Entries[i];
string fn = f.FullName;
if (fn.PathEqualsI(Paths.FMSelInf) ||
fn.PathEqualsI(_startMisSav) ||
(fn.Length > 0 && fn[fn.Length - 1].IsDirSep()) ||
fileExcludes.PathContainsI(fn))
{
continue;
}
if (fn.ContainsDirSep())
{
Directory.CreateDirectory(Path.Combine(fmInstalledPath, fn.Substring(0, fn.LastIndexOfDirSep())));
}
f.ExtractToFile(Path.Combine(fmInstalledPath, fn), overwrite: true);
}
}
}
}
if (!restoreSavesAndScreensOnly)
{
foreach (string f in Directory.GetFiles(fmInstalledPath, "*", SearchOption.AllDirectories))
{
if (fileExcludes.PathContainsI(f.Substring(fmInstalledPath.Length).Trim(CA_BS_FS)))
{
// TODO: Deleted dirs are not detected, they're detected as "delete every file in this dir"
// If we have crf files replacing dirs, the empty dir will override the crf. We want
// to store whether dirs were actually removed so we can remove them again.
File.Delete(f);
}
}
// Disabled till this is working completely
#if false
// Crappy hack method
var crfs = Directory.GetFiles(fmInstalledPath, "*.crf", SearchOption.TopDirectoryOnly);
var dirRemoveList = new List <string>();
foreach (string d in Directory.GetDirectories(fmInstalledPath, "*", SearchOption.TopDirectoryOnly))
{
string dt = d.GetDirNameFast();
if (Directory.GetFiles(d, "*", SearchOption.AllDirectories).Length == 0)
{
for (int i = 0; i < crfs.Length; i++)
{
string ft = crfs[i].GetFileNameFast().RemoveExtension();
if (ft.PathEqualsI(dt))
{
dirRemoveList.Add(d);
}
}
}
}
if (dirRemoveList.Count > 0)
{
for (int i = 0; i < dirRemoveList.Count; i++)
{
Directory.Delete(dirRemoveList[i], recursive: true);
}
}
// Proper method
foreach (string d in Directory.GetDirectories(fmInstalledPath, "*", SearchOption.AllDirectories))
{
if (dirExcludes.PathContainsI(d.Substring(fmInstalledPath.Length).Trim(CA_BS_FS)))
{
Directory.Delete(d, recursive: true);
}
}
#endif
}
if (fileToUse.DarkLoader)
{
string dlOrigBakDir = Path.Combine(Config.FMsBackupPath, Paths.DarkLoaderSaveOrigBakDir);
Directory.CreateDirectory(dlOrigBakDir);
File.Move(fileToUse.Name, Path.Combine(dlOrigBakDir, fileToUse.Name.GetFileNameFast()));
}
});
}
// MT: On startup only, this is run in parallel with MainForm.ctor and .InitThreadable()
// So don't touch anything the other touches: anything affecting the view.
// @CAN_RUN_BEFORE_VIEW_INIT
private static List <int> FindInternal(bool startup)
{
if (!startup)
{
// Make sure we don't lose anything when we re-find!
// NOTE: This also writes out TagsStrings and then reads them back in and syncs them with Tags.
// Critical that that gets done.
Ini.WriteFullFMDataIni();
// Do this every time we modify FMsViewList in realtime, to prevent FMsDGV from redrawing from
// the list when it's in an indeterminate state (which can cause a selection change (bad) and/or
// a visible change of the list (not really bad but unprofessional looking)).
// MT: Don't do this on startup because we're running in parallel with the form new/init in that case.
Core.View.SetRowCount(0);
}
// Init or reinit - must be deep-copied or changes propagate back because reference types
// MT: This is thread-safe, the view ctor and InitThreadable() doesn't touch it.
PresetTags.DeepCopyTo(GlobalTags);
#region Back up lists and read FM data file
// Copy FMs to backup lists before clearing, in case we can't read the ini file. We don't want to end
// up with a blank or incomplete list and then glibly save it out later.
FanMission[] backupList = new FanMission[FMDataIniList.Count];
FMDataIniList.CopyTo(backupList);
FanMission[] viewBackupList = new FanMission[FMsViewList.Count];
FMsViewList.CopyTo(viewBackupList);
FMDataIniList.Clear();
FMsViewList.Clear();
bool fmDataIniExists = File.Exists(Paths.FMDataIni);
if (fmDataIniExists)
{
try
{
Ini.ReadFMDataIni(Paths.FMDataIni, FMDataIniList);
}
catch (Exception ex)
{
Log("Exception reading FM data ini", ex);
if (startup)
{
// Language will be loaded by this point
Dialogs.ShowError(LText.AlertMessages.FindFMs_ExceptionReadingFMDataIni);
Core.EnvironmentExitDoShutdownTasks(1);
}
else
{
FMDataIniList.ClearAndAdd(backupList);
FMsViewList.ClearAndAdd(viewBackupList);
return(new List <int>());
}
}
}
#endregion
#region Get installed dirs from disk
// Could check inside the folder for a .mis file to confirm it's really an FM folder, but that's
// horrendously expensive. Talking like eight seconds vs. < 4ms for the 1098 set. Weird.
var perGameInstFMDirsList = new List <List <string> >(SupportedGameCount);
var perGameInstFMDirsDatesList = new List <List <DateTime> >(SupportedGameCount);
for (int gi = 0; gi < SupportedGameCount; gi++)
{
// NOTE! Make sure this list ends up with SupportedGameCount items in it. Just in case I change
// the loop or something.
perGameInstFMDirsList.Add(new List <string>());
perGameInstFMDirsDatesList.Add(new List <DateTime>());
string instPath = Config.GetFMInstallPath((GameIndex)gi);
if (Directory.Exists(instPath))
{
try
{
var dirs = FastIO.GetDirsTopOnly_FMs(instPath, "*", out List <DateTime> dateTimes);
for (int di = 0; di < dirs.Count; di++)
{
string d = dirs[di];
if (!d.EqualsI(Paths.FMSelCache))
{
perGameInstFMDirsList[gi].Add(d);
perGameInstFMDirsDatesList[gi].Add(dateTimes[di]);
}
}
}
catch (Exception ex)
{
Log("Exception getting directories in " + instPath, ex);
}
}
}
#endregion
#region Get archives from disk
var fmArchivesAndDatesDict = new DictionaryI <DateTime>();
var archivePaths = FMArchives.GetFMArchivePaths();
bool onlyOnePath = archivePaths.Count == 1;
for (int ai = 0; ai < archivePaths.Count; ai++)
{
try
{
// Returns filenames only (not full paths)
var files = FastIO.GetFilesTopOnly_FMs(archivePaths[ai], "*", out List <DateTime> dateTimes);
for (int fi = 0; fi < files.Count; fi++)
{
string f = files[fi];
// Do this first because it should be faster than a dictionary lookup
if (!f.ExtIsArchive())
{
continue;
}
// NOTE: We do a ContainsKey check to keep behavior the same as previously. When we use
// dict[key] = value, it _replaces_ the value with the new one every time. What we want
// is for it to just not touch it at all if the key is already in there. This check does
// technically slow it down some, but the actual perf degradation is negligible. And we
// still avoid the n-squared 1.6-million-call nightmare we get with ~1600 FMs in the list.
// Nevertheless, we can avoid even this small extra cost if we only have one FM archive
// path, so no harm in keeping the only-one-path check.
if ((onlyOnePath || !fmArchivesAndDatesDict.ContainsKey(f)) &&
// @DIRSEP: These are filename only, no need for PathContainsI()
!f.ContainsI(Paths.FMSelBak))
{
fmArchivesAndDatesDict[f] = dateTimes[fi];
}
}
}
catch (Exception ex)
{
Log("Exception getting files in " + archivePaths[ai], ex);
}
}
int fmArchivesAndDatesDictLen = fmArchivesAndDatesDict.Count;
// PERF_TODO: May want to keep these as dicts later or change other vars to dicts
string[] fmArchives = new string[fmArchivesAndDatesDictLen];
DateTime[] fmArchivesDates = new DateTime[fmArchivesAndDatesDictLen];
{
int i = 0;
foreach (var item in fmArchivesAndDatesDict)
{
fmArchives[i] = item.Key;
fmArchivesDates[i] = item.Value;
i++;
}
}
#endregion
#region Build FanMission objects from installed dirs
var perGameFMsList = new List <List <FanMission> >(SupportedGameCount);
for (int gi = 0; gi < SupportedGameCount; gi++)
{
// NOTE! List must have SupportedGameCount items in it
perGameFMsList.Add(new List <FanMission>());
for (int di = 0; di < perGameInstFMDirsList[gi].Count; di++)
{
perGameFMsList[gi].Add(new FanMission
{
InstalledDir = perGameInstFMDirsList[gi][di],
Game = GameIndexToGame((GameIndex)gi),
Installed = true
});
}
}
#endregion
MergeNewArchiveFMs(fmArchives, fmArchivesDates);
int instInitCount = FMDataIniList.Count;
for (int i = 0; i < SupportedGameCount; i++)
{
var curGameInstFMsList = perGameFMsList[i];
if (curGameInstFMsList.Count > 0)
{
MergeNewInstalledFMs(curGameInstFMsList, perGameInstFMDirsDatesList[i], instInitCount);
}
}
SetArchiveNames(fmArchives);
SetInstalledNames();
// Super quick-n-cheap hack for perf: So we don't have to iterate the whole list looking for unscanned
// FMs. This will contain indexes into FMDataIniList (not FMsViewList!)
var fmsViewListUnscanned = new List <int>(FMDataIniList.Count);
BuildViewList(fmArchives, perGameInstFMDirsList, fmsViewListUnscanned);
return(fmsViewListUnscanned);
/*
* TODO: There's an extreme corner case where duplicate FMs can appear in the list
* It's so unlikely it's almost not worth worrying about, but here's the scenario:
* -The FM is installed by hand and not truncated
* -The FM is not in the list
* -A matching archive exists for the FM
* In this scenario, the FM is added twice to the list, once with the full installed folder name and
* NoArchive set to true, and once with a truncated installed dir name, the correct archive name, and
* NoArchive not present (false).
* The code in here is so crazy-go-nuts I can't even find where this is happening. But putting this
* note down for the future.
*/
}
internal static async Task <bool> InstallFM(FanMission fm)
{
#region Checks
AssertR(!fm.Installed, "fm.Installed == false");
if (!GameIsKnownAndSupported(fm.Game))
{
Log("FM game type is unknown or unsupported.\r\n" +
"FM: " + (!fm.Archive.IsEmpty() ? fm.Archive : fm.InstalledDir) + "\r\n" +
"FM game was: " + fm.Game);
Dialogs.ShowError(ErrorText.FMGameTypeUnknownOrUnsupported);
return(false);
}
GameIndex gameIndex = GameToGameIndex(fm.Game);
string fmArchivePath = FMArchives.FindFirstMatch(fm.Archive);
if (fmArchivePath.IsEmpty())
{
Log("FM archive field was empty; this means an archive was not found for it on the last search.\r\n" +
"FM: " + (!fm.Archive.IsEmpty() ? fm.Archive : fm.InstalledDir) + "\r\n" +
"FM game was: " + fm.Game);
Dialogs.ShowError(LText.AlertMessages.Install_ArchiveNotFound);
return(false);
}
string gameExe = Config.GetGameExe(gameIndex);
string gameName = GetLocalizedGameName(gameIndex);
if (!File.Exists(gameExe))
{
Log("Game executable not found.\r\n" +
"Game executable: " + gameExe);
Dialogs.ShowError(gameName + ":\r\n" +
LText.AlertMessages.Install_ExecutableNotFound);
return(false);
}
string instBasePath = Config.GetFMInstallPath(gameIndex);
if (!Directory.Exists(instBasePath))
{
Log("FM install path not found.\r\n" +
"FM: " + (!fm.Archive.IsEmpty() ? fm.Archive : fm.InstalledDir) + "\r\n" +
"FM game was: " + fm.Game + "\r\n" +
"FM install path: " + instBasePath
);
Dialogs.ShowError(gameName + ":\r\n" +
LText.AlertMessages.Install_FMInstallPathNotFound);
return(false);
}
if (GameIsRunning(gameExe))
{
Dialogs.ShowAlert(gameName + ":\r\n" +
LText.AlertMessages.Install_GameIsRunning, LText.AlertMessages.Alert);
return(false);
}
#endregion
string fmInstalledPath = Path.Combine(instBasePath, fm.InstalledDir);
_extractCts = new CancellationTokenSource();
Core.View.ShowProgressBox(ProgressTask.InstallFM);
// Framework zip extracting is much faster, so use it if possible
bool canceled = !await(fmArchivePath.ExtIsZip()
? Task.Run(() => InstallFMZip(fmArchivePath, fmInstalledPath))
: Task.Run(() => InstallFMSevenZip(fmArchivePath, fmInstalledPath)));
if (canceled)
{
Core.View.SetCancelingFMInstall();
await Task.Run(() =>
{
try
{
Directory.Delete(fmInstalledPath, recursive: true);
}
catch (Exception ex)
{
// @BetterErrors(InstallFM() - install cancellation (folder deletion) failed)
Log("Unable to delete FM installed directory " + fmInstalledPath, ex);
}
});
Core.View.HideProgressBox();
return(false);
}
fm.Installed = true;
Ini.WriteFullFMDataIni();
try
{
using var sw = new StreamWriter(Path.Combine(fmInstalledPath, Paths.FMSelInf), append: false);
await sw.WriteLineAsync("Name=" + fm.InstalledDir);
await sw.WriteLineAsync("Archive=" + fm.Archive);
}
catch (Exception ex)
{
Log("Couldn't create " + Paths.FMSelInf + " in " + fmInstalledPath, ex);
}
// Only Dark engine games need audio conversion
if (GameIsDark(gameIndex))
{
try
{
Core.View.ShowProgressBox(ProgressTask.ConvertFiles);
// Dark engine games can't play MP3s, so they must be converted in all cases.
// This one won't be called anywhere except during install, because it always runs during
// install so there's no need to make it optional elsewhere. So we don't need to have a
// check bool or anything.
await FMAudio.ConvertToWAVs(fm, AudioConvert.MP3ToWAV, false);
if (Config.ConvertOGGsToWAVsOnInstall)
{
await FMAudio.ConvertToWAVs(fm, AudioConvert.OGGToWAV, false);
}
if (Config.ConvertWAVsTo16BitOnInstall)
{
await FMAudio.ConvertToWAVs(fm, AudioConvert.WAVToWAV16, false);
}
}
catch (Exception ex)
{
Log("Exception in audio conversion", ex);
}
}
// Don't be lazy about this; there can be no harm and only benefits by doing it right away
GenerateMissFlagFileIfRequired(fm);
// TODO: Put up a "Restoring saves and screenshots" box here to avoid the "converting files" one lasting beyond its time?
try
{
await RestoreFM(fm);
}
catch (Exception ex)
{
Log(ex: ex);
}
finally
{
Core.View.HideProgressBox();
}
// Not doing RefreshFM(rowOnly: true) because that wouldn't update the install/uninstall buttons
Core.View.RefreshFM(fm);
return(true);
}
GetFMSupportedLanguagesFromArchive(string archiveName, bool earlyOutOnEnglish)
{
// @DIRSEP: '/' conversion in here due to string.IndexOf()
(bool, List <string>)failed = (false, new List <string>());
string archivePath = FMArchives.FindFirstMatch(archiveName);
if (archivePath.IsEmpty())
{
return(failed);
}
var ret = new List <string>(Supported.Length);
bool[] FoundLangInArchive = new bool[Supported.Length];
// Pre-concat each string only once for perf
string[] SLangsFSPrefixed = new string[Supported.Length];
for (int i = 0; i < Supported.Length; i++)
{
SLangsFSPrefixed[i] = "/" + Supported[i];
}
FMScanner.FastZipReader.ZipArchiveFast?zipArchive = null;
SevenZipExtractor?sevenZipArchive = null;
try
{
bool fmIsZip = archivePath.ExtIsZip();
if (fmIsZip)
{
zipArchive = new FMScanner.FastZipReader.ZipArchiveFast(File.OpenRead(archivePath));
}
else
{
sevenZipArchive = new SevenZipExtractor(archivePath);
}
int filesCount = fmIsZip ? zipArchive !.Entries.Count : (int)sevenZipArchive !.FilesCount;
for (int i = 0; i < filesCount; i++)
{
string fn = fmIsZip
// ZipArchiveFast guarantees full names to never contain backslashes
? zipArchive !.Entries[i].FullName
// For some reason ArchiveFileData[i].FileName is like 20x faster than ArchiveFileNames[i]
: sevenZipArchive !.ArchiveFileData[i].FileName.ToForwardSlashes();
for (int j = 0; j < Supported.Length; j++)
{
string sl = Supported[j];
if (!FoundLangInArchive[j])
{
// Do as few string operations as humanly possible
int index = fn.IndexOf(SLangsFSPrefixed[j], StringComparison.OrdinalIgnoreCase);
if (index < 1)
{
continue;
}
if ((fn.Length > index + sl.Length + 1 && fn[index + sl.Length + 1] == '/') ||
(index == (fn.Length - sl.Length) - 1))
{
if (earlyOutOnEnglish && j == 0)
{
return(true, new List <string> {
"English"
});
}
ret.Add(sl);
FoundLangInArchive[j] = true;
}
}
}
}
}
catch (Exception ex)
{
Log("Scanning archive '" + archivePath + "' for languages failed.", ex);
return(false, new List <string>());
}
finally
{
zipArchive?.Dispose();
sevenZipArchive?.Dispose();
}
return(true, ret);
}
