private async void Menu_Backup_Click(object sender, RoutedEventArgs e)
{
var result = FlexibleMessageBox.Show(UIMessages.CreateBackupsMessage, UIMessages.CreateBackupsTitle, MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (result == System.Windows.Forms.DialogResult.Yes)
{
var gameDirectory = new DirectoryInfo(Settings.Default.FFXIV_Directory);
var problemChecker = new ProblemChecker(gameDirectory);
var backupsDirectory = new DirectoryInfo(Properties.Settings.Default.Backup_Directory);
try
{
await problemChecker.BackupIndexFiles(backupsDirectory);
}
catch (Exception ex)
{
FlexibleMessageBox.Show(string.Format(UIMessages.BackupFailedErrorMessage, ex.Message), UIMessages.BackupFailedTitle, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
await this.ShowMessageAsync(UIMessages.BackupCompleteTitle, UIMessages.BackupCompleteMessage);
}
}
/// <summary>
/// Performs post-patch modlist corrections and validation, prompting user also to generate backups after a successful completion.
/// </summary>
/// <returns></returns>
public async Task DoPostPatchCleanup()
{
FlexibleMessageBox.Show(_mainWindow.Win32Window, UIMessages.PatchDetectedMessage, "Post Patch Cleanup Starting", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
MainWindow.MakeHighlander();
var resetLumina = false;
await _mainWindow.LockUi("Performing Post-Patch Maintenence", "This may take a few minutes if you have many mods installed.", this);
var gi = XivCache.GameInfo;
if (XivCache.GameInfo.UseLumina)
{
resetLumina = true;
XivCache.SetGameInfo(gi.GameDirectory, gi.GameLanguage, gi.DxMode, false, false, gi.LuminaDirectory, gi.UseLumina);
}
var workerStatus = XivCache.CacheWorkerEnabled;
if (workerStatus)
{
// Stop the cache worker if it's running.
XivCache.CacheWorkerEnabled = false;
}
try
{
var modding = new Modding(_gameDirectory);
var _index = new Index(_gameDirectory);
var _dat = new Dat(_gameDirectory);
var validTypes = new List <int>()
{
2, 3, 4
};
// We have to do a few things here.
// 1. Save a list of what mods were enabled.
// 2. Go through and validate everything that says it is enabled actually is enabled, or mark it as disabled and update its original index offset if it is not.
// 3. Prompt the user for either a full disable and backup creation, or a restore to normal state (re-enable anything that was enabled before but is not now)
var modList = modding.GetModList();
Dictionary <XivDataFile, IndexFile> indexFiles = new Dictionary <XivDataFile, IndexFile>();
// Cache our currently enabled stuff.
List <Mod> enabledMods = modList.Mods.Where(x => x.enabled == true).ToList();
var toRemove = new List <Mod>();
foreach (var mod in modList.Mods)
{
if (!String.IsNullOrEmpty(mod.fullPath))
{
var df = IOUtil.GetDataFileFromPath(mod.fullPath);
if (!indexFiles.ContainsKey(df))
{
indexFiles[df] = await _index.GetIndexFile(df);
}
var index1Value = indexFiles[df].Get8xDataOffset(mod.fullPath);
var index2Value = indexFiles[df].Get8xDataOffsetIndex2(mod.fullPath);
var oldOriginalOffset = mod.data.originalOffset;
var modOffset = mod.data.modOffset;
// In any event where an offset does not match either of our saved offsets, we must assume this is a new
// default file offset for post-patch.
if (index1Value != oldOriginalOffset && index1Value != modOffset && index1Value != 0)
{
// Index 1 value is our new base offset.
var type = _dat.GetFileType(index1Value, df);
// Make sure the file it's trying to point to is actually valid.
if (validTypes.Contains(type))
{
mod.data.originalOffset = index1Value;
mod.enabled = false;
}
else
{
// Oh dear. The new index is f****d. Is the old Index Ok?
type = _dat.GetFileType(oldOriginalOffset, df);
if (validTypes.Contains(type) && oldOriginalOffset != 0)
{
// Old index is fine, so keep using that.
// But mark the index value as invalid, so that we stomp on the index value after this.
index1Value = -1;
mod.enabled = false;
}
else
{
// Okay... Maybe the new Index2 Value?
if (index2Value != 0)
{
type = _dat.GetFileType(index2Value, df);
if (validTypes.Contains(type))
{
// Set the index 1 value to invalid so that the if later down the chain stomps the index1 value.
index1Value = -1;
mod.data.originalOffset = index2Value;
mod.enabled = false;
}
else
{
// We be f****d.
throw new Exception("Unable to determine working original offset for file:" + mod.fullPath);
}
}
else
{
// We be f****d.
throw new Exception("Unable to determine working original offset for file:" + mod.fullPath);
}
}
}
}
else if (index2Value != oldOriginalOffset && index2Value != modOffset && index2Value != 0)
{
// Our Index 1 was normal, but our Index 2 is changed to an unknown value.
// If the index 2 points to a valid file, we must assume that this new file
// is our new base data offset.
var type = _dat.GetFileType(index2Value, df);
if (validTypes.Contains(type) && index2Value != 0)
{
mod.data.originalOffset = index2Value;
mod.enabled = false;
}
else
{
// Oh dear. The new index is f****d. Is the old Index Ok?
type = _dat.GetFileType(oldOriginalOffset, df);
if (validTypes.Contains(type) && oldOriginalOffset != 0)
{
// Old index is fine, so keep using that, but set the index2 value to invalid to ensure we
// stomp on the current broken index value.
index2Value = -1;
}
else
{
// We be f****d.
throw new Exception("Unable to determine working original offset for file:" + mod.fullPath);
}
}
}
// Indexes don't match. This can occur if SE adds something to index2 that didn't exist in index2 before.
if (index1Value != index2Value && index2Value != 0)
{
// We should never actually get to this state for file-addition mods. If we do, uh.. I guess correct the indexes and yolo?
// ( Only way we get here is if SE added a new file at the same name as a file the user had created via modding, in which case, it's technically no longer a file addition mod )
indexFiles[df].SetDataOffset(mod.fullPath, mod.data.originalOffset);
index1Value = mod.data.originalOffset;
index2Value = mod.data.originalOffset;
mod.enabled = false;
}
// Set it to the corrected state.
if (index1Value == mod.data.modOffset)
{
mod.enabled = true;
}
else
{
mod.enabled = false;
}
// Perform a basic file type check on our results.
var fileType = _dat.GetFileType(mod.data.modOffset, IOUtil.GetDataFileFromPath(mod.fullPath));
var originalFileType = _dat.GetFileType(mod.data.modOffset, IOUtil.GetDataFileFromPath(mod.fullPath));
if (!validTypes.Contains(fileType) || mod.data.modOffset == 0)
{
// Mod data is busted. Fun.
toRemove.Add(mod);
}
if ((!validTypes.Contains(originalFileType)) || mod.data.originalOffset == 0)
{
if (mod.IsCustomFile())
{
// Okay, in this case this is recoverable as the mod is a custom addition anyways, so we can just delete it.
if (!toRemove.Contains(mod))
{
toRemove.Add(mod);
}
}
else
{
// Update ended up with us unable to find a working offset. Double fun.
throw new Exception("Unable to determine working offset for file:" + mod.fullPath);
}
}
}
// Okay, this mod is now represented in the modlist in it's actual post-patch index state.
var datNum = (int)((mod.data.modOffset / 8) & 0x0F) / 2;
var dat = XivDataFiles.GetXivDataFile(mod.datFile);
var originalDats = await _dat.GetUnmoddedDatList(dat);
var datPath = $"{dat.GetDataFileName()}{Dat.DatExtension}{datNum}";
// Test for SE Dat file rollover.
if (originalDats.Contains(datPath))
{
// Shit. This means that the dat file where this mod lived got eaten by SE. We have to destroy the modlist entry at this point.
toRemove.Add(mod);
}
}
// Save any index changes we made.
foreach (var dkv in indexFiles)
{
await _index.SaveIndexFile(dkv.Value);
}
// The modlist is now saved in its current index-represented post patch state.
modding.SaveModList(modList);
// We now need to clear out any mods that are irreparably f****d, and clear out all of our
// internal data files so we can rebuild them later.
var internalFiles = modList.Mods.Where(x => x.IsInternal());
toRemove.AddRange(internalFiles);
if (toRemove.Count > 0)
{
var removedString = "";
// Soft-Disable all metadata mods, since we're going to purge their internal file entries.
var metadata = modList.Mods.Where(x => x.fullPath.EndsWith(".meta") || x.fullPath.EndsWith(".rgsp"));
foreach (var mod in metadata)
{
var df = IOUtil.GetDataFileFromPath(mod.fullPath);
await modding.ToggleModUnsafe(false, mod, true, false, indexFiles[df], modList);
}
foreach (var mod in toRemove)
{
if (mod.data.modOffset == 0 || mod.data.originalOffset == 0)
{
if (mod.data.originalOffset == 0 && mod.enabled)
{
// This is awkward. We have a mod whose data got bashed, but has no valid original offset to restore.
// So the indexes here are f****d if we do, f****d if we don't.
throw new Exception("Patch-Broken file has no valid index to restore. Clean Index Restoration required.");
}
modList.Mods.Remove(mod);
enabledMods.Remove(mod);
removedString += mod.fullPath + "\n";
}
else
{
if (mod.enabled)
{
var df = IOUtil.GetDataFileFromPath(mod.fullPath);
await modding.ToggleModUnsafe(false, mod, true, false, indexFiles[df], modList);
}
modList.Mods.Remove(mod);
// Since we're deleting this entry entirely, we can't leave it in the other cached list either to get re-enabled later.
enabledMods.Remove(mod);
if (!mod.IsInternal())
{
removedString += mod.fullPath + "\n";
}
}
}
// Save the index files and modlist again now that we've removed all the invalid entries.
foreach (var dkv in indexFiles)
{
await _index.SaveIndexFile(dkv.Value);
}
modding.SaveModList(modList);
// Show the user a message if we purged any real files.
if (toRemove.Any(x => !String.IsNullOrEmpty(x.fullPath) && !x.IsInternal()))
{
var text = String.Format(UIMessages.PatchDestroyedFiles, removedString);
FlexibleMessageBox.Show(_mainWindow.Win32Window, text, "Destroyed Files Notification", MessageBoxButtons.OK, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1);
}
}
// Always create clean index backups after this process is completed.
_mainWindow.LockProgress.Report("Disabling Mods...");
await modding.ToggleAllMods(false);
_mainWindow.LockProgress.Report("Creating Index Backups...");
var pc = new ProblemChecker(_gameDirectory);
DirectoryInfo backupDir;
try
{
Directory.CreateDirectory(Settings.Default.Backup_Directory);
backupDir = new DirectoryInfo(Settings.Default.Backup_Directory);
}
catch
{
throw new Exception("Unable to create index backups.\nThe Index Backup directory is invalid or inaccessible: " + Settings.Default.Backup_Directory);
}
await pc.BackupIndexFiles(backupDir);
// Now restore the modlist enable/disable state back to how the user had it before.
_mainWindow.LockProgress.Report("Re-Enabling mods...");
// Re-enable things.
await modding.ToggleMods(true, enabledMods.Select(x => x.fullPath));
FlexibleMessageBox.Show(_mainWindow.Win32Window, UIMessages.PostPatchComplete, "Post-Patch Process Complete", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
}
catch (Exception Ex)
{
// Show the user the error, then let them go about their business of fixing things.
FlexibleMessageBox.Show(_mainWindow.Win32Window, String.Format(UIMessages.PostPatchError, Ex.Message), "Post-Patch Failure", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
}
finally
{
if (resetLumina)
{
// Reset lumina mode back to on if we disabled it to perform update checks.
XivCache.SetGameInfo(gi.GameDirectory, gi.GameLanguage, gi.DxMode, true, false, gi.LuminaDirectory, true);
}
XivCache.CacheWorkerEnabled = workerStatus;
await _mainWindow.UnlockUi(this);
}
}
