private void LoadME2FilesList()
{
var me2files = new List <BackupFile>();
var bup = Utilities.GetGameBackupPath(Mod.MEGame.ME2);
if (bup != null)
{
var target = new GameTarget(Mod.MEGame.ME2, bup, false);
var cookedPath = MEDirectories.CookedPath(target);
foreach (var f in Extensions.GetFiles(cookedPath, @"\.pcc|\.tfc|\.afc|\.bin|\.tlk", SearchOption.AllDirectories))
{
me2files.Add(new BackupFile(@"BASEGAME", Path.GetFileName(f)));
}
var dlcDir = MEDirectories.DLCPath(target);
var officialDLC = VanillaDatabaseService.GetInstalledOfficialDLC(target);
foreach (var v in officialDLC)
{
var cookedDLCPath = Path.Combine(dlcDir, v, @"CookedPC");
if (Directory.Exists(cookedDLCPath))
{
foreach (var f in Directory.EnumerateFiles(cookedDLCPath, @"*.pcc", SearchOption.TopDirectoryOnly))
{
me2files.Add(new BackupFile(v, Path.GetFileName(f)));
}
}
}
}
Application.Current.Dispatcher.Invoke(delegate
{
ME2Files.ReplaceAll(me2files);
});
Debug.WriteLine(@"Num ME2 files: " + ME2Files.Count);
}
private void LoadME1FilesList()
{
var me1files = new List <BackupFile>();
var bup = BackupService.GetGameBackupPath(Mod.MEGame.ME1);
if (bup != null)
{
var target = new GameTarget(Mod.MEGame.ME1, bup, false);
var cookedPath = MEDirectories.CookedPath(target);
foreach (var f in Extensions.GetFiles(cookedPath, @"\.u|\.upk|\.sfm", SearchOption.AllDirectories))
{
me1files.Add(new BackupFile(@"BASEGAME", Path.GetFileName(f)));
}
me1files.Sort(); //sort basegame
var dlcDir = MEDirectories.DLCPath(target);
var officialDLC = VanillaDatabaseService.GetInstalledOfficialDLC(target);
foreach (var v in officialDLC)
{
var cookedDLCPath = Path.Combine(dlcDir, v, @"CookedPC");
if (Directory.Exists(cookedDLCPath))
{
var filesToAdd = new List <BackupFile>();
foreach (var f in Extensions.GetFiles(cookedDLCPath, @"\.u|\.upk|\.sfm", SearchOption.AllDirectories))
{
filesToAdd.Add(new BackupFile(v, Path.GetFileName(f)));
}
filesToAdd.Sort();
me1files.AddRange(filesToAdd);
}
}
}
Application.Current.Dispatcher.Invoke(delegate
{
ME1Files.ReplaceAll(me1files);
});
Debug.WriteLine(@"Num ME1 files: " + ME2Files.Count);
}
private void CompileIntoGame()
{
NamedBackgroundWorker nbw = new NamedBackgroundWorker(@"MixinManager CompileIntoGameThread");
List <string> failedApplications = new List <string>();
nbw.DoWork += (a, b) =>
{
BottomLeftMessage = M3L.GetString(M3L.string_compilingMixins);
OperationInProgress = true;
//DEBUG STUFF
#if DEBUG
int numCoresToApplyWith = 1;
#else
var numCoresToApplyWith = Environment.ProcessorCount;
if (numCoresToApplyWith > 4)
{
numCoresToApplyWith = 4; //no more than 4 as this uses a lot of memory
}
#endif
var mixins = AvailableOfficialMixins.Where(x => x.UISelectedForUse).ToList();
MixinHandler.LoadPatchDataForMixins(mixins); //before dynamic
void failedApplicationCallback(string str)
{
failedApplications.Add(str);
}
var compilingListsPerModule = MixinHandler.GetMixinApplicationList(mixins, failedApplicationCallback);
if (failedApplications.Any())
{
//Error building list
Log.Information(@"Aborting mixin install due to incompatible selection of mixins");
return;
}
ProgressBarMax = mixins.Count();
ProgressBarValue = 0;
int numdone = 0;
void completedSingleApplicationCallback()
{
var val = Interlocked.Increment(ref numdone);
ProgressBarValue = val;
}
//Mixins are ready to be applied
Parallel.ForEach(compilingListsPerModule,
new ParallelOptions
{
MaxDegreeOfParallelism = Environment.ProcessorCount > numCoresToApplyWith
? numCoresToApplyWith
: Environment.ProcessorCount
}, mapping =>
{
var dlcFolderName = ModMakerCompiler.ModmakerChunkNameToDLCFoldername(mapping.Key.ToString());
//var outdir = Path.Combine(modpath, ModMakerCompiler.HeaderToDefaultFoldername(mapping.Key), @"CookedPCConsole");
//Directory.CreateDirectory(outdir);
if (mapping.Key == ModJob.JobHeader.BASEGAME)
{
//basegame
foreach (var file in mapping.Value)
{
try
{
using var vanillaPackageAsStream = VanillaDatabaseService.FetchBasegameFile(Mod.MEGame.ME3, Path.GetFileName(file.Key));
//packageAsStream.WriteToFile(@"C:\users\dev\desktop\compressed.pcc");
using var decompressedStream = MEPackage.GetDecompressedPackageStream(vanillaPackageAsStream, true);
decompressedStream.Position = 0;
var vanillaPackage = MEPackageHandler.OpenMEPackage(decompressedStream, $@"Vanilla - {Path.GetFileName(file.Key)}");
//decompressedStream.WriteToFile(@"C:\users\dev\desktop\decompressed.pcc");
using var mixinModifiedStream = MixinHandler.ApplyMixins(decompressedStream, file.Value,
completedSingleApplicationCallback, failedApplicationCallback);
mixinModifiedStream.Position = 0;
var modifiedPackage = MEPackageHandler.OpenMEPackage(mixinModifiedStream, $@"Mixin Modified - {Path.GetFileName(file.Key)}");
// three way merge: get target stream
var targetFile = Path.Combine(MEDirectories.CookedPath(SelectedInstallTarget), Path.GetFileName(file.Key));
var targetPackage = MEPackageHandler.OpenMEPackage(targetFile);
var merged = ThreeWayPackageMerge.AttemptMerge(vanillaPackage, modifiedPackage, targetPackage);
if (merged)
{
targetPackage.save();
Log.Information("Three way merge succeeded for " + targetFile);
}
else
{
Log.Error("Could not merge three way merge into " + targetFile);
}
//var outfile = Path.Combine(outdir, Path.GetFileName(file.Key));
//package.save(outfile, false); // don't compress
//finalStream.WriteToFile(outfile);
//File.WriteAllBytes(outfile, finalStream.ToArray());
}
catch (Exception e)
{
var mixinsStr = string.Join(@", ", file.Value.Select(x => x.PatchName));
Log.Error($@"Error in mixin application for file {file.Key}: {e.Message}");
failedApplicationCallback(M3L.GetString(M3L.string_interp_errorApplyingMixinsForFile, mixinsStr, file.Key, e.Message));
}
}
}
else
{
//dlc
var dlcPackage = VanillaDatabaseService.FetchVanillaSFAR(dlcFolderName); //do not have to open file multiple times.
var targetCookedPCDir = Path.Combine(MEDirectories.DLCPath(SelectedInstallTarget), dlcFolderName, @"CookedPCConsole");
var sfar = mapping.Key == ModJob.JobHeader.TESTPATCH ? Utilities.GetTestPatchPath(SelectedInstallTarget) : Path.Combine(targetCookedPCDir, @"Default.sfar");
bool unpacked = new FileInfo(sfar).Length == 32;
DLCPackage targetDLCPackage = unpacked ? null : new DLCPackage(sfar); //cache SFAR target
foreach (var file in mapping.Value)
{
try
{
using var vanillaPackageAsStream = VanillaDatabaseService.FetchFileFromVanillaSFAR(dlcFolderName, file.Key, forcedDLC: dlcPackage);
using var decompressedStream = MEPackage.GetDecompressedPackageStream(vanillaPackageAsStream);
decompressedStream.Position = 0;
var vanillaPackage = MEPackageHandler.OpenMEPackage(decompressedStream, $@"VanillaDLC - {Path.GetFileName(file.Key)}");
using var mixinModifiedStream = MixinHandler.ApplyMixins(decompressedStream, file.Value, completedSingleApplicationCallback, failedApplicationCallback);
mixinModifiedStream.Position = 0;
var modifiedPackage = MEPackageHandler.OpenMEPackage(mixinModifiedStream, $@"Mixin Modified - {Path.GetFileName(file.Key)}");
// three way merge: get target stream
// must see if DLC is unpacked first
MemoryStream targetFileStream = null;
//Packed
if (unpacked)
{
targetFileStream = new MemoryStream(File.ReadAllBytes(Path.Combine(targetCookedPCDir, file.Key)));
}
else
{
targetFileStream = VanillaDatabaseService.FetchFileFromVanillaSFAR(dlcFolderName, Path.GetFileName(file.Key), forcedDLC: targetDLCPackage);
}
var targetPackage = MEPackageHandler.OpenMEPackage(targetFileStream, $@"Target package {dlcFolderName} - {file.Key}, from SFAR: {unpacked}");
var merged = ThreeWayPackageMerge.AttemptMerge(vanillaPackage, modifiedPackage, targetPackage);
if (merged)
{
if (unpacked)
{
targetPackage.save();
Log.Information("Three way merge succeeded for " + targetPackage.FilePath);
}
else
{
var finalSTream = targetPackage.saveToStream();
targetDLCPackage.ReplaceEntry(finalSTream.ToArray(), targetDLCPackage.FindFileEntry(Path.GetFileName(file.Key)));
Log.Information("Three way merge succeeded for " + targetPackage.FileSourceForDebugging);
}
}
else
{
Log.Error("Could not merge three way merge into " + targetFileStream);
}
}
catch (Exception e)
{
var mixinsStr = string.Join(@", ", file.Value.Select(x => x.PatchName));
Log.Error($@"Error in mixin application for file {file.Key}: {e.Message}");
failedApplicationCallback(M3L.GetString(M3L.string_interp_errorApplyingMixinsForFile, mixinsStr, file.Key, e.Message));
}
//finalStream.WriteToFile(outfile);
}
}
});
MixinHandler.FreeME3TweaksPatchData();
var percent = 0; //this is used to save a localization
BottomLeftMessage = $"Running AutoTOC on game {percent}%";
//Run autotoc
void tocingUpdate(int percent)
{
BottomLeftMessage = $"Running AutoTOC on game {percent}%";
}
AutoTOC.RunTOCOnGameTarget(SelectedInstallTarget, tocingUpdate);
//Generate moddesc
//IniData ini = new IniData();
//ini[@"ModManager"][@"cmmver"] = App.HighestSupportedModDesc.ToString(CultureInfo.InvariantCulture); //prevent commas
//ini[@"ModInfo"][@"game"] = @"ME3";
//ini[@"ModInfo"][@"modname"] = modname;
//ini[@"ModInfo"][@"moddev"] = App.AppVersionHR;
//ini[@"ModInfo"][@"moddesc"] = M3L.GetString(M3L.string_compiledFromTheFollowingMixins);
//ini[@"ModInfo"][@"modver"] = @"1.0";
//generateRepaceFilesMapping(ini, modpath);
//File.WriteAllText(Path.Combine(modpath, @"moddesc.ini"), ini.ToString());
};
nbw.RunWorkerCompleted += (a, b) =>
{
OperationInProgress = false;
ClearMixinHandler();
if (failedApplications.Count > 0)
{
var ld = new ListDialog(failedApplications, M3L.GetString(M3L.string_failedToApplyAllMixins), M3L.GetString(M3L.string_theFollowingMixinsFailedToApply), mainwindow);
ld.ShowDialog();
}
/*if (modpath != null)
* {
* OnClosing(new DataEventArgs(modpath));
* }
* else
* {*/
BottomLeftMessage = "Mixins installed, maybe. Check logs";
//}
};
CompilePanelButton.IsOpen = false;
nbw.RunWorkerAsync();
}
internal static ExportEntry FindExternalAsset(ImportEntry entry, List <ExportEntry> alreadyLoadedPackageEntries)
{
//Debug.WriteLine("Finding external asset " + entry.GetFullPath);
if (entry.Game == MEGame.ME1)
{
var sourcePackageInternalPath = entry.FullPath.Substring(entry.FullPath.IndexOf('.') + 1);
string baseName = entry.FileRef.FollowLink(entry.idxLink).Split('.')[0].ToUpper() + ".upk"; //Get package filename
var preloadedPackageEntry = alreadyLoadedPackageEntries?.FirstOrDefault(x => Path.GetFileName(x.FileRef.FilePath).Equals(baseName, StringComparison.InvariantCultureIgnoreCase));
if (preloadedPackageEntry == null && MELoadedFiles.GetFilesLoadedInGame(MEGame.ME1).TryGetValue(baseName, out string packagePath))
{
var package = MEPackageHandler.OpenMEPackage(packagePath);
var foundExp = package.Exports.FirstOrDefault(exp => exp.FullPath == sourcePackageInternalPath && exp.ClassName == entry.ClassName);
if (foundExp != null)
{
return(foundExp);
}
package.Dispose();
}
else
{
Debug.WriteLine("ME1 External Asset lookup: Using existing preloaded export package");
var foundExp = preloadedPackageEntry.FileRef.Exports.FirstOrDefault(exp => exp.FullPath == sourcePackageInternalPath && exp.ClassName == entry.ClassName);
if (foundExp != null)
{
return(foundExp);
}
}
}
else
{
// Next, split the filename by underscores
string filenameWithoutExtension = Path.GetFileNameWithoutExtension(entry.FileRef.FilePath).ToLower();
string containingDirectory = Path.GetDirectoryName(entry.FileRef.FilePath);
var packagesToCheck = new List <string>();
var gameFiles = MELoadedFiles.GetFilesLoadedInGame(entry.Game);
if (filenameWithoutExtension.StartsWith("bioa_") || filenameWithoutExtension.StartsWith("biod_"))
{
string[] parts = filenameWithoutExtension.Split('_');
if (parts.Length >= 2) //BioA_Nor_WowThatsAlot310.pcc
{
string bioad = $"{parts[0]}_{parts[1]}.pcc";
string filename = Path.Combine(containingDirectory, bioad); //BioA_Nor.pcc
if (File.Exists(filename))
{
packagesToCheck.Add(filename);
}
else
{
if (gameFiles.TryGetValue(filename, out string inGamePath))
{
packagesToCheck.Add(inGamePath);
}
}
string biop = $"BioP_{parts[1]}.pcc";
filename = Path.Combine(containingDirectory, biop); //BioP_Nor.pcc
if (File.Exists(filename))
{
packagesToCheck.Add(filename);
}
else
{
if (gameFiles.TryGetValue(filename, out string inGamePath))
{
packagesToCheck.Add(inGamePath);
}
}
}
}
foreach (string packagePath in packagesToCheck)
{
var preloadedPackageEntry = alreadyLoadedPackageEntries?.FirstOrDefault(x => Path.GetFileName(x.FileRef.FilePath).Equals(packagePath, StringComparison.InvariantCultureIgnoreCase));
if (preloadedPackageEntry == null)
{
Debug.WriteLine("ME2/3 External Asset lookup: Checking " + packagePath);
var package = MEPackageHandler.OpenMEPackage(packagePath);
var foundExp = package.Exports.FirstOrDefault(exp => exp.FullPath == entry.FullPath && exp.ClassName == entry.ClassName);
if (foundExp != null)
{
return(foundExp);
}
//Debug.WriteLine("ME2/3 External Asset lookup: Not found, disposing " + packagePath);
package.Dispose();
}
else
{
Debug.WriteLine("ME2/3 External Asset lookup: Using existing preloaded export package");
var foundExp = preloadedPackageEntry.FileRef.Exports.FirstOrDefault(exp => exp.FullPath == entry.FullPath && exp.ClassName == entry.ClassName);
if (foundExp != null)
{
return(foundExp);
}
}
}
//Check SFXGame
string sfxgamePath = Path.Combine(MEDirectories.CookedPath(entry.Game), "SFXGame.pcc");
if (File.Exists(sfxgamePath))
{
//This is not in using statement as we have to keep this in memory.
IMEPackage pcc = MEPackageHandler.OpenMEPackage(sfxgamePath);
var foundExp = pcc.Exports.FirstOrDefault(exp => exp.FullPath == entry.FullPath && exp.ClassName == entry.ClassName);
if (foundExp != null)
{
return(foundExp);
}
//Debug.WriteLine("ME2/3 External Asset lookup: Not SFXGame, disposing");
pcc.Dispose(); //Dump from memory
}
//Check EntryMenu
string entryMenuPath = Path.Combine(MEDirectories.CookedPath(entry.Game), "EntryMenu.pcc");
if (File.Exists(entryMenuPath))
{
//This is not in using statement as we have to keep this in memory.
IMEPackage pcc = MEPackageHandler.OpenMEPackage(entryMenuPath);
var foundExp = pcc.Exports.FirstOrDefault(exp => exp.FullPath == entry.FullPath && exp.ClassName == entry.ClassName);
if (foundExp != null)
{
return(foundExp);
}
//Debug.WriteLine("ME2/3 External Asset lookup: Not EntryMenu, disposing");
pcc.Dispose(); //Dump from memory
}
//Check Startup
string startupPath = Path.Combine(MEDirectories.CookedPath(entry.Game), "Startup.pcc");
if (File.Exists(startupPath))
{
//This is not in using statement as we have to keep this in memory.
IMEPackage pcc = MEPackageHandler.OpenMEPackage(startupPath);
var foundExp = pcc.Exports.FirstOrDefault(exp => exp.FullPath == entry.FullPath && exp.ClassName == entry.ClassName);
if (foundExp != null)
{
return(foundExp);
}
//Debug.WriteLine("ME2/3 External Asset lookup: Not Startup, disposing");
pcc.Dispose(); //Dump from memory
}
}
Debug.WriteLine("Could not find external asset: " + entry.FullPath);
return(null);
}