public static bool RandomizeWeapons(RandomizationOption option)
{
var me2rbioweapon = CoalescedHandler.GetIniFile("BIOWeapon.ini");
// We must manually fetch game files cause MERFS will return the ini from the dlc mod instead.
ME2Coalesced me2basegamecoalesced = new ME2Coalesced(MERFileSystem.GetSpecificFile(@"BioGame\Config\PC\Cooked\Coalesced.ini"));
MERLog.Information("Randomizing basegame weapon ini");
var bioweapon = me2basegamecoalesced.Inis.FirstOrDefault(x => Path.GetFileName(x.Key) == "BIOWeapon.ini").Value;
RandomizeWeaponIni(bioweapon, me2rbioweapon);
var weaponInis = Directory.GetFiles(MEDirectories.GetDLCPath(MERFileSystem.Game), "BIOWeapon.ini", SearchOption.AllDirectories).ToList();
foreach (var wi in weaponInis)
{
if (wi.Contains($"DLC_MOD_{MERFileSystem.Game}Randomizer"))
{
continue; // Skip randomizer folders
}
MERLog.Information($@"Randomizing weapon ini {wi}");
//Log.Information("Randomizing weapons in ini: " + wi);
var dlcWeapIni = DuplicatingIni.LoadIni(wi);
RandomizeWeaponIni(dlcWeapIni, me2rbioweapon);
//if (!MERFileSystem.UsingDLCModFS)
//{
// Log.Information("Writing DLC BioWeapon: " + wi);
// File.WriteAllText(wi, dlcWeapIni.ToString());
//}
}
return(true);
}
/// <summary>
/// Gets a list of all files that *may* be installed by a mod.
/// </summary>
/// <returns></returns>
public List <string> GetAllInstallableFiles()
{
var list = new List <string>();
foreach (var job in InstallationJobs)
{
if (ModJob.IsVanillaJob(job, Game))
{
// Basegame, Official DLC
list.AddRange(job.FilesToInstall.Keys);
}
else if (job.Header == ModJob.JobHeader.CUSTOMDLC)
{
foreach (var cdlcDir in job.CustomDLCFolderMapping)
{
var dlcSourceDir = Path.Combine(ModPath, cdlcDir.Key);
var files = Directory.GetFiles(dlcSourceDir, @"*", SearchOption.AllDirectories).Select(x => x.Substring(dlcSourceDir.Length + 1));
list.AddRange(files.Select(x => $@"{MEDirectories.GetDLCPath(Game, @"")}\{cdlcDir.Value}\{x}")); // do not localize
}
}
foreach (var v in job.AlternateFiles)
{
if (v.Operation == AlternateFile.AltFileOperation.OP_INSTALL)
{
list.Add(v.ModFile);
}
if (v.Operation == AlternateFile.AltFileOperation.OP_APPLY_MULTILISTFILES)
{
foreach (var mlFile in v.MultiListSourceFiles)
{
list.Add(v.MultiListTargetPath + @"\" + mlFile);
}
}
}
foreach (var v in job.AlternateDLCs)
{
if (v.Operation == AlternateDLC.AltDLCOperation.OP_ADD_CUSTOMDLC || v.Operation == AlternateDLC.AltDLCOperation.OP_ADD_FOLDERFILES_TO_CUSTOMDLC)
{
var dlcSourceDir = Path.Combine(ModPath, v.AlternateDLCFolder);
var files = Directory.GetFiles(dlcSourceDir, @"*", SearchOption.AllDirectories).Select(x => x.Substring(dlcSourceDir.Length + 1));
list.AddRange(files.Select(x => $@"{MEDirectories.GetDLCPath(Game, @"")}\{v.DestinationDLCFolder}\{x}")); //do not localize
}
if (v.Operation == AlternateDLC.AltDLCOperation.OP_ADD_MULTILISTFILES_TO_CUSTOMDLC)
{
foreach (var mlFile in v.MultiListSourceFiles)
{
list.Add(v.DestinationDLCFolder + @"\" + mlFile);
}
}
}
}
return(list.Distinct().OrderBy(x => x).ToList());
}
/// <summary>
/// Gets a list of allowable and not-allowable directories that can be installed to by this job. Disallowed always overrides allowed and if an item is not listed in allowed it is implicitly not allowed
/// </summary>
/// <param name="job"></param>
/// <param name="game"></param>
/// <returns></returns>
public static SiloScopes GetScopedSilos(ModJob job, MEGame game)
{
switch (job.Header)
{
case JobHeader.LOCALIZATION:
case JobHeader.ME1_CONFIG:
case JobHeader.ME2_RCWMOD:
case JobHeader.BALANCE_CHANGES:
return(null); // There are no scopes for these headers.
}
SiloScopes scopes = new SiloScopes();
var dlcDir = MEDirectories.GetDLCPath(game, "") + Path.DirectorySeparatorChar;
if (job.Header == JobHeader.BASEGAME)
{
// There are specific directories we allow installation to.
if (game == MEGame.ME3)
{
scopes.DisallowedSilos.Add(@"Binaries\\Win32" + Path.DirectorySeparatorChar); //You are not allowed to install files into the game executable directory. ME1/2 unfortuantely share exec with exe dir.
}
scopes.AllowedSilos.Add(@"Binaries" + Path.DirectorySeparatorChar); //Exec files
scopes.AllowedSilos.Add(@"BioGame" + Path.DirectorySeparatorChar); // Stuff in biogame
scopes.AllowedSilos.Add(@"data" + Path.DirectorySeparatorChar); // Stuff in biogame
scopes.DisallowedSilos.Add(dlcDir); // BASEGAME is not allowed into DLC
scopes.AllowedSilos.Add(@"Engine" + Path.DirectorySeparatorChar); //Shaders
}
else if (GetHeadersToDLCNamesMap(game).TryGetValue(job.Header, out var dlcFoldername))
{
// It's an official DLC
var relativeDlcDir = Path.Combine(MEDirectories.GetDLCPath(game, ""), dlcFoldername) + Path.DirectorySeparatorChar;
scopes.AllowedSilos.Add(relativeDlcDir); //Silos are folders. We should ensure they end with a slash
}
else if (job.Header == JobHeader.CUSTOMDLC)
{
// Have to get all resolved target folders. These are the scopes.AllowedSilos
foreach (var cdlcn in job.CustomDLCFolderMapping.Values)
{
scopes.AllowedSilos.Add(Path.Combine(dlcDir, cdlcn) + Path.DirectorySeparatorChar);
}
// Get alternate dlc targets
foreach (var adlc in job.AlternateDLCs.Where(x => x.Operation == AlternateDLC.AltDLCOperation.OP_ADD_CUSTOMDLC))
{
scopes.AllowedSilos.Add(Path.Combine(dlcDir, adlc.DestinationDLCFolder) + Path.DirectorySeparatorChar);
}
}
return(scopes);
}
public MixinManager()
{
MemoryAnalyzer.AddTrackedMemoryItem(@"Mixin Library Panel", new WeakReference(this));
MixinHandler.LoadME3TweaksPackage();
AvailableOfficialMixins.ReplaceAll(MixinHandler.ME3TweaksPackageMixins.OrderBy(x => x.PatchName));
var backupPath = BackupService.GetGameBackupPath(MEGame.ME3);
if (backupPath != null)
{
var dlcPath = MEDirectories.GetDLCPath(MEGame.ME3, backupPath);
var headerTranslation = ModJob.GetHeadersToDLCNamesMap(MEGame.ME3);
foreach (var mixin in AvailableOfficialMixins)
{
mixin.UIStatusChanging += MixinUIStatusChanging;
if (mixin.TargetModule == ModJob.JobHeader.TESTPATCH)
{
if (File.Exists(ME3Directory.GetTestPatchSFARPath(backupPath)))
{
mixin.CanBeUsed = true;
}
}
else if (mixin.TargetModule != ModJob.JobHeader.BASEGAME)
{
//DLC
var resolvedPath = Path.Combine(dlcPath, headerTranslation[mixin.TargetModule]);
if (Directory.Exists(resolvedPath))
{
mixin.CanBeUsed = true;
}
}
else
{
//BASEGAME
mixin.CanBeUsed = true;
}
}
}
else
{
BottomLeftMessage = M3L.GetString(M3L.string_noGameBackupOfME3IsAvailableMixinsCannotBeUsedWithoutABackup);
}
ResetMixinsUIState();
LoadCommands();
InitializeComponent();
}
public static string GetDLCPath(GameTarget target) => MEDirectories.GetDLCPath(target.Game, target.TargetPath);
private void BeginRestore()
{
if (Utilities.IsGameRunning(Game))
{
M3L.ShowDialog(window, M3L.GetString(M3L.string_interp_dialogCannotRestoreXWhileItIsRunning, Game.ToGameName()), M3L.GetString(M3L.string_gameRunning), MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
var useNewMethod = M3L.ShowDialog(window,
M3L.GetString(M3L.string_beta_useNewRestoreMethod),
M3L.GetString(M3L.string_useBetaFeatureQuestion), MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes;
bool restore = RestoreTarget.IsCustomOption || useNewMethod; //custom option is restore to custom location
restore = restore || M3L.ShowDialog(window, M3L.GetString(M3L.string_dialog_restoringXWillDeleteGameDir, Game.ToGameName()), M3L.GetString(M3L.string_gameTargetWillBeDeleted), MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes;
if (restore)
{
NamedBackgroundWorker nbw = new NamedBackgroundWorker(Game + @"-Restore");
nbw.WorkerReportsProgress = true;
nbw.ProgressChanged += (a, b) =>
{
if (b.UserState is double d)
{
TaskbarHelper.SetProgress(d);
}
};
nbw.DoWork += (a, b) =>
{
RestoreInProgress = true;
// Nuke the LODs
if (!RestoreTarget.IsCustomOption && RestoreTarget.Game.IsOTGame())
{
Log.Information($@"Resetting LODs for {RestoreTarget.Game}");
Utilities.SetLODs(RestoreTarget, false, false, false);
}
string restoreTargetPath = b.Argument as string;
string backupPath = BackupLocation;
if (!useNewMethod)
{
BackupStatusLine2 = M3L.GetString(M3L.string_deletingExistingGameInstallation);
if (Directory.Exists(restoreTargetPath))
{
if (Directory.GetFiles(restoreTargetPath).Any() ||
Directory.GetDirectories(restoreTargetPath).Any())
{
Log.Information(@"Deleting existing game directory: " + restoreTargetPath);
try
{
bool deletedDirectory =
Utilities.DeleteFilesAndFoldersRecursively(restoreTargetPath);
if (deletedDirectory != true)
{
b.Result = RestoreResult.ERROR_COULD_NOT_DELETE_GAME_DIRECTORY;
return;
}
}
catch (Exception ex)
{
//todo: handle this better
Log.Error(
$@"Exception deleting game directory: {restoreTargetPath}: {ex.Message}");
b.Result = RestoreResult.EXCEPTION_DELETING_GAME_DIRECTORY;
return;
}
}
}
else
{
Log.Error(@"Game directory not found! Was it removed while the app was running?");
}
var created = Utilities.CreateDirectoryWithWritePermission(restoreTargetPath);
if (!created)
{
b.Result = RestoreResult.ERROR_COULD_NOT_CREATE_DIRECTORY;
return;
}
}
BackupStatusLine2 = M3L.GetString(M3L.string_restoringGameFromBackup);
if (restoreTargetPath != null)
{
//callbacks
#region callbacks
void fileCopiedCallback()
{
ProgressValue++;
if (ProgressMax != 0)
{
nbw.ReportProgress(0, ProgressValue * 1.0 / ProgressMax);
}
}
string dlcFolderpath = MEDirectories.GetDLCPath(Game, backupPath) + '\\'; //\ at end makes sure we are restoring a subdir
int dlcSubStringLen = dlcFolderpath.Length;
Debug.WriteLine(@"DLC Folder: " + dlcFolderpath);
Debug.Write(@"DLC Folder path len:" + dlcFolderpath);
bool aboutToCopyCallback(string fileBeingCopied)
{
if (fileBeingCopied.Contains(@"\cmmbackup\"))
{
return(false); //do not copy cmmbackup files
}
Debug.WriteLine(fileBeingCopied);
if (fileBeingCopied.StartsWith(dlcFolderpath, StringComparison.InvariantCultureIgnoreCase))
{
//It's a DLC!
string dlcname = fileBeingCopied.Substring(dlcSubStringLen);
int index = dlcname.IndexOf('\\');
if (index > 0) //Files directly in the DLC directory won't have path sep
{
try
{
dlcname = dlcname.Substring(0, index);
if (MEDirectories.OfficialDLCNames(RestoreTarget.Game).TryGetValue(dlcname, out var hrName))
{
BackupStatusLine2 = M3L.GetString(M3L.string_interp_restoringX, hrName);
}
else
{
BackupStatusLine2 = M3L.GetString(M3L.string_interp_restoringX, dlcname);
}
}
catch (Exception e)
{
Crashes.TrackError(e, new Dictionary <string, string>()
{
{ @"Source", @"Restore UI display callback" },
{ @"Value", fileBeingCopied },
{ @"DLC Folder path", dlcFolderpath }
});
}
}
}
else
{
//It's basegame
if (fileBeingCopied.EndsWith(@".bik"))
{
BackupStatusLine2 = M3L.GetString(M3L.string_restoringMovies);
}
else if (new FileInfo(fileBeingCopied).Length > 52428800)
{
BackupStatusLine2 = M3L.GetString(M3L.string_interp_restoringX, Path.GetFileName(fileBeingCopied));
}
else
{
BackupStatusLine2 = M3L.GetString(M3L.string_restoringBasegame);
}
}
return(true);
}
void totalFilesToCopyCallback(int total)
{
ProgressValue = 0;
ProgressIndeterminate = false;
ProgressMax = total;
}
#endregion
BackupStatus = M3L.GetString(M3L.string_restoringGame);
// LE: Backup Config file so settings don't get lost
string configText = null;
var configPath = RestoreTarget.Game.IsLEGame() ? M3Directories.GetLODConfigFile(RestoreTarget) : null;
if (File.Exists(configPath))
{
configText = File.ReadAllText(configPath); // backup to memory
}
Log.Information($@"Copying backup to game directory: {backupPath} -> {restoreTargetPath}");
if (useNewMethod)
{
string CurrentRCFile = null;
RoboCommand rc = new RoboCommand();
rc.CopyOptions.Destination = restoreTargetPath;
rc.CopyOptions.Source = backupPath;
rc.CopyOptions.Mirror = true;
rc.CopyOptions.MultiThreadedCopiesCount = 2;
rc.OnCopyProgressChanged += (sender, args) =>
{
ProgressIndeterminate = false;
ProgressValue = (int)args.CurrentFileProgress;
ProgressMax = 100;
};
rc.OnFileProcessed += (sender, args) =>
{
if (args.ProcessedFile.Name.StartsWith(backupPath) && args.ProcessedFile.Name.Length > backupPath.Length)
{
CurrentRCFile = args.ProcessedFile.Name.Substring(backupPath.Length + 1);
BackupStatusLine2 = M3L.GetString(M3L.string_interp_copyingX, CurrentRCFile);
}
};
rc.Start().Wait();
}
else
{
CopyDir.CopyAll_ProgressBar(new DirectoryInfo(backupPath),
new DirectoryInfo(restoreTargetPath),
totalItemsToCopyCallback: totalFilesToCopyCallback,
aboutToCopyCallback: aboutToCopyCallback,
fileCopiedCallback: fileCopiedCallback,
ignoredExtensions: new[] { @"*.pdf", @"*.mp3" });
}
Log.Information(@"Restore of game data has completed");
if (configText != null)
{
// Restore config file
try
{
Directory.CreateDirectory(Directory.GetParent(configPath).FullName);
File.WriteAllText(configPath, configText);
Log.Information(@"Restored config file");
}
catch (Exception e)
{
Log.Error($@"Could not restore config file: {e.Message}");
}
}
BackupCopyFinished(restoreTargetPath);
}
};
nbw.RunWorkerCompleted += (a, b) =>
{
if (b.Error != null)
{
Log.Error($@"Exception occurred in {nbw.Name} thread: {b.Error.Message}");
}
TaskbarHelper.SetProgressState(TaskbarProgressBarState.NoProgress);
if (b.Result is RestoreResult result)
{
switch (result)
{
case RestoreResult.ERROR_COULD_NOT_CREATE_DIRECTORY:
Analytics.TrackEvent(@"Restored game", new Dictionary <string, string>()
{
{ @"Game", Game.ToString() },
{ @"Result", @"Failure, Could not create target directory" }
});
M3L.ShowDialog(window, M3L.GetString(M3L.string_dialogCouldNotCreateGameDirectoryAfterDeletion), M3L.GetString(M3L.string_errorRestoringGame), MessageBoxButton.OK, MessageBoxImage.Error);
break;
case RestoreResult.ERROR_COULD_NOT_DELETE_GAME_DIRECTORY:
Analytics.TrackEvent(@"Restored game", new Dictionary <string, string>()
{
{ @"Game", Game.ToString() },
{ @"Result", @"Failure, Could not delete existing game directory" }
});
M3L.ShowDialog(window, M3L.GetString(M3L.string_dialogcouldNotFullyDeleteGameDirectory), M3L.GetString(M3L.string_errorRestoringGame), MessageBoxButton.OK, MessageBoxImage.Error);
break;
case RestoreResult.EXCEPTION_DELETING_GAME_DIRECTORY:
Analytics.TrackEvent(@"Restored game", new Dictionary <string, string>()
{
{ @"Game", Game.ToString() },
{ @"Result", @"Failure, Exception deleting existing game directory" }
});
M3L.ShowDialog(window, M3L.GetString(M3L.string_dialogErrorOccuredDeletingGameDirectory), M3L.GetString(M3L.string_errorRestoringGame), MessageBoxButton.OK, MessageBoxImage.Error);
break;
case RestoreResult.RESTORE_OK:
Analytics.TrackEvent(@"Restored game", new Dictionary <string, string>()
{
{ @"Game", Game.ToString() },
{ @"Result", @"Success" }
});
break;
}
}
EndRestore();
CommandManager.InvalidateRequerySuggested();
};
var restoreTargetPath = RestoreTarget.TargetPath;
if (RestoreTarget.IsCustomOption)
{
CommonOpenFileDialog m = new CommonOpenFileDialog
{
IsFolderPicker = true,
EnsurePathExists = true,
Title = M3L.GetString(M3L.string_selectNewRestoreDestination)
};
if (m.ShowDialog() == CommonFileDialogResult.Ok)
{
//Check empty
restoreTargetPath = m.FileName;
if (Directory.Exists(restoreTargetPath))
{
if (Directory.GetFiles(restoreTargetPath).Length > 0 || Directory.GetDirectories(restoreTargetPath).Length > 0)
{
Log.Warning($@"The selected restore directory is not empty: {restoreTargetPath}");
//Directory not empty
if (!useNewMethod)
{
M3L.ShowDialog(window,
M3L.GetString(M3L
.string_dialogDirectoryIsNotEmptyLocationToRestoreToMustBeEmpty),
M3L.GetString(M3L.string_cannotRestoreToThisLocation), MessageBoxButton.OK,
MessageBoxImage.Error);
return;
}
else
{
// Warn user
var shouldContinue = MessageBoxResult.Yes == M3L.ShowDialog(window,
M3L.GetString(M3L.string_interp_directoryNotEmptyWillDeleteEverything, restoreTargetPath),
M3L.GetString(M3L.string_directoryNotEmpty), MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (!shouldContinue)
{
return;
}
Log.Warning($@"The user is continuing to new-gen restore on existing directory anyways");
}
}
//TODO: PREVENT RESTORING TO DOCUMENTS/BIOWARE
}
Analytics.TrackEvent(@"Chose to restore game to custom location", new Dictionary <string, string>()
{
{ @"Game", Game.ToString() },
{ @"New-gen", useNewMethod.ToString() }
});
}
else
{
return;
}
}
RefreshTargets = true;
TaskbarHelper.SetProgress(0);
TaskbarHelper.SetProgressState(TaskbarProgressBarState.Normal);
nbw.RunWorkerAsync(restoreTargetPath);
}
}
