public static void ExecuteConsoleCommands(IntPtr hWnd, MEGame game, IEnumerable <string> commands)
{
const string execFileName = "me3expinterop";
string execFilePath = Path.Combine(MEDirectories.GetDefaultGamePath(game), "Binaries", execFileName);
File.WriteAllText(execFilePath, string.Join(Environment.NewLine, commands));
DirectExecuteConsoleCommand(hWnd, $"exec {execFileName}");
}
public static void TestAllImportsInMERFS()
{
var dlcModPath = Path.Combine(MEDirectories.GetDefaultGamePath(MERFileSystem.Game), "BioGame", "DLC", $"DLC_MOD_{MERFileSystem.Game}Randomizer", "CookedPC");
var packages = Directory.GetFiles(dlcModPath);
var globalCache = MERFileSystem.GetGlobalCache();
//var globalP = Path.Combine(dlcModPath, "BioP_Global.pcc");
//if (File.Exists(globalP))
//{
// // This is used for animation lookups.
// globalCache.InsertIntoCache(MEPackageHandler.OpenMEPackage(globalP));
//}
foreach (var p in packages)
{
if (p.RepresentsPackageFilePath())
{
MERPackageCache localCache = new MERPackageCache();
Debug.WriteLine($"Checking package file {p}");
var pack = MEPackageHandler.OpenMEPackage(p);
foreach (var imp in pack.Imports)
{
if (imp.InstancedFullPath.StartsWith("Core.") || imp.InstancedFullPath.StartsWith("Engine."))
{
continue; // These have some natives are always in same file.
}
if (imp.InstancedFullPath == "BioVFX_Z_TEXTURES.Generic.Glass_Shards_Norm" && MERFileSystem.Game == MEGame.ME2)
{
continue; // This is... native for some reason?
}
var resolvedExp = EntryImporter.ResolveImport(imp, globalCache, localCache);
if (resolvedExp == null)
{
Debug.WriteLine($"Could not resolve import: {imp.InstancedFullPath}");
}
}
}
}
Debug.WriteLine("Done checking imports");
}
public static void GetExportsInPersistentThatAreAlsoInSub()
{
var dlcModPath = Path.Combine(MEDirectories.GetDefaultGamePath(MERFileSystem.Game), "BioGame", "DLC", $"DLC_MOD_{MERFileSystem.Game}Randomizer", "CookedPC");
var oldPersistentFile = MEPackageHandler.OpenMEPackage(Path.Combine(@"B:\SteamLibrary\steamapps\common\Mass Effect 2\BioGame\CookedPC", "BioP_JnkKgA.pcc"));
var newPersistentFile = MEPackageHandler.OpenMEPackage(Path.Combine(dlcModPath, "BioP_JnkKgA.pcc"));
var oldExpList = oldPersistentFile.Exports.Select(x => x.InstancedFullPath);
var newExpList = newPersistentFile.Exports.Select(x => x.InstancedFullPath);
var newExports = newExpList.Except(oldExpList).ToList();
var subFile = MEPackageHandler.OpenMEPackage(@"B:\SteamLibrary\steamapps\common\Mass Effect 2\BioGame\CookedPC\BioD_JnkKgA_300Labs.pcc");
var subExports = subFile.Exports.Select(x => x.InstancedFullPath);
var sameExports = subExports.Intersect(newExports).ToList();
foreach (var v in sameExports)
{
Debug.WriteLine(v);
}
}
public static void TestPropertiesInMERFS()
{
var dlcModPath = Path.Combine(MEDirectories.GetDefaultGamePath(MERFileSystem.Game), "BioGame", "DLC", $"DLC_MOD_{MERFileSystem.Game}Randomizer", "CookedPC");
ReferenceCheckPackage rcp = new ReferenceCheckPackage();
bool checkCanceled = false;
EntryChecker.CheckReferences(rcp, dlcModPath, EntryChecker.NonLocalizedStringConverter, x => Debug.WriteLine(x));
foreach (var s in rcp.GetInfoWarnings())
{
Debug.WriteLine($"INFO: {s}");
}
foreach (var s in rcp.GetSignificantIssues())
{
Debug.WriteLine($"SIGNIFICANT: {s}");
}
foreach (var s in rcp.GetBlockingErrors())
{
Debug.WriteLine($"BLOCKING: {s}");
}
}
public static async void BeginFlow(MainWindow window)
{
// PRE LIBRARY LOAD
RegistryHandler.RegistrySettingsPath = @"HKEY_CURRENT_USER\Software\MassEffect2Randomizer";
RegistryHandler.CurrentUserRegistrySubpath = @"Software\MassEffect2Randomizer";
LegendaryExplorerCoreLib.SetSynchronizationContext(TaskScheduler.FromCurrentSynchronizationContext());
try
{
// This is in a try catch because this is a critical no-crash zone that is before launch
window.Title = $"Mass Effect 2 Randomizer {App.AppVersion}";
}
catch { }
if (Utilities.GetExecutablePath().StartsWith(Path.GetTempPath(), StringComparison.InvariantCultureIgnoreCase))
{
// Running from temp! This is not allowed
await window.ShowMessageAsync("Cannot run from temp directory", $"Mass Effect 2 Randomizer cannot be run from the system's Temp directory. If this executable was run from within an archive, it needs to be extracted first.");
Environment.Exit(1);
}
var pd = await window.ShowProgressAsync("Starting up", $"Mass Effect 2 Randomizer is starting up. Please wait.");
pd.SetIndeterminate();
NamedBackgroundWorker bw = new NamedBackgroundWorker("StartupThread");
bw.DoWork += (a, b) =>
{
ALOTInstallerCoreLib.Startup(SetWrapperLogger, RunOnUIThread, startTelemetry, stopTelemetry, $"Mass Effect 2 Randomizer {App.AppVersion} starting up", false);
// Logger is now available
// Setup telemetry handlers
CoreAnalytics.TrackEvent = TelemetryController.TrackEvent;
CoreCrashes.TrackError = TelemetryController.TrackError;
CoreCrashes.TrackError2 = TelemetryController.TrackError2;
CoreCrashes.TrackError3 = TelemetryController.TrackError3;
// Setup the InteropPackage for the update check
#region Update interop
CancellationTokenSource ct = new CancellationTokenSource();
AppUpdateInteropPackage interopPackage = new AppUpdateInteropPackage()
{
GithubOwner = "Mgamerz",
GithubReponame = "MassEffect2Randomizer",
UpdateAssetPrefix = "ME2Randomizer",
UpdateFilenameInArchive = "ME2Randomizer.exe",
ShowUpdatePromptCallback = (title, text, updateButtonText, declineButtonText) =>
{
bool response = false;
object syncObj = new object();
Application.Current.Dispatcher.Invoke(async() =>
{
if (Application.Current.MainWindow is MainWindow mw)
{
var result = await mw.ShowMessageAsync(title, text, MessageDialogStyle.AffirmativeAndNegative, new MetroDialogSettings()
{
AffirmativeButtonText = updateButtonText,
NegativeButtonText = declineButtonText,
DefaultButtonFocus = MessageDialogResult.Affirmative
},
75);
response = result == MessageDialogResult.Affirmative;
lock (syncObj)
{
Monitor.Pulse(syncObj);
}
}
});
lock (syncObj)
{
Monitor.Wait(syncObj);
}
return(response);
},
ShowUpdateProgressDialogCallback = (title, initialmessage, canCancel) =>
{
// We don't use this as we are already in a progress dialog
pd.SetCancelable(canCancel);
pd.SetMessage(initialmessage);
pd.SetTitle(title);
},
SetUpdateDialogTextCallback = s =>
{
pd.SetMessage(s);
},
ProgressCallback = (done, total) =>
{
pd.SetProgress(done * 1d / total);
pd.SetMessage($"Downloading update {FileSize.FormatSize(done)} / {FileSize.FormatSize(total)}");
},
ProgressIndeterminateCallback = () =>
{
pd.SetIndeterminate();
},
ShowMessageCallback = (title, message) =>
{
object syncObj = new object();
Application.Current.Dispatcher.Invoke(async() =>
{
if (Application.Current.MainWindow is MainWindow mw)
{
await mw.ShowMessageAsync(title, message);
lock (syncObj)
{
Monitor.Pulse(syncObj);
}
}
});
lock (syncObj)
{
Monitor.Wait(syncObj);
}
},
NotifyBetaAvailable = () =>
{
App.BetaAvailable = true;
},
DownloadCompleted = () =>
{
pd.SetCancelable(false);
},
cancellationTokenSource = ct,
ApplicationName = "Mass Effect 2 Randomizer",
RequestHeader = "ME2Randomizer",
ForcedUpgradeMaxReleaseAge = 3
};
#endregion
pd.SetMessage("Checking for application updates");
pd.Canceled += (sender, args) =>
{
ct.Cancel();
};
AppUpdater.PerformGithubAppUpdateCheck(interopPackage);
// If user aborts download
pd.SetCancelable(false);
pd.SetIndeterminate();
pd.SetTitle("Starting up");
void setStatus(string message)
{
pd.SetIndeterminate();
pd.SetMessage(message);
}
GameTarget target = null;
try
{
pd.SetMessage("Loading Mass Effect 2 Randomizer framework");
ToolTipService.ShowOnDisabledProperty.OverrideMetadata(typeof(Control), new FrameworkPropertyMetadata(true));
ToolTipService.ShowDurationProperty.OverrideMetadata(typeof(DependencyObject), new FrameworkPropertyMetadata(int.MaxValue));
ALOTInstallerCoreLib.PostCriticalStartup(x => pd.SetMessage(x), RunOnUIThread, false);
#if __LE2__
LE2Directory.ReloadDefaultGamePath(true);
if (LE2Directory.DefaultGamePath != null)
{
GameTarget gt = new GameTarget(MEGame.LE2, LE2Directory.DefaultGamePath, true);
if (gt.ValidateTarget() == null)
{
Locations.SetTarget(gt, false);
}
}
#endif
MEPackageHandler.GlobalSharedCacheEnabled = false; // ME2R does not use the global shared cache.
handleM3Passthrough();
target = Locations.GetTarget(MERFileSystem.Game);
if (target == null)
{
var gamePath = MEDirectories.GetDefaultGamePath(MERFileSystem.Game);
if (Directory.Exists(gamePath))
{
target = new GameTarget(MERFileSystem.Game, gamePath, true);
var validationFailedReason = target.ValidateTarget();
if (validationFailedReason == null)
{
// CHECK NOT TEXTURE MODIFIED
if (target.TextureModded)
{
MERLog.Error($@"Game target is texture modded: {target.TargetPath}. This game target is not targetable by ME2R");
object o = new object();
Application.Current.Dispatcher.Invoke(async() =>
{
if (Application.Current.MainWindow is MainWindow mw)
{
await mw.ShowMessageAsync("Mass Effect 2 target is texture modded", $"The game located at {target.TargetPath} has had textures modified. Mass Effect 2 Randomizer cannot randomize texture modified games, as it adds package files. If you want to texture mod your game, it must be done after randomization.", ContentWidthPercent: 75);
lock (o)
{
Monitor.Pulse(o);
}
}
});
lock (o)
{
Monitor.Wait(o);
}
}
// We still set target so we can restore game if necessary
Locations.SetTarget(target, false);
}
}
}
pd.SetMessage("Performing startup checks");
MERStartupCheck.PerformStartupCheck((title, message) =>
{
object o = new object();
Application.Current.Dispatcher.Invoke(async() =>
{
if (Application.Current.MainWindow is MainWindow mw)
{
await mw.ShowMessageAsync(title, message, ContentWidthPercent: 75);
lock (o)
{
Monitor.Pulse(o);
}
}
});
lock (o)
{
Monitor.Wait(o);
}
}, x => pd.SetMessage(x));
// force initial refresh
MERPeriodicRefresh(null, null);
}
catch (Exception e)
{
MERLog.Exception(e, @"There was an error starting up the framework!");
}
pd.SetMessage("Preparing interface");
Thread.Sleep(250); // This will allow this message to show up for moment so user can see it.
Application.Current.Dispatcher.Invoke(async() =>
{
if (Application.Current.MainWindow is MainWindow mw)
{
mw.SetupTargetDescriptionText();
var backupStatus = BackupService.GetBackupStatus(MERFileSystem.Game);
mw.BackupRestoreText = backupStatus?.BackupActionText;
mw.BackupRestore_Button.ToolTip = backupStatus != null && backupStatus.BackedUp ? "Click to restore game/uninstall randomizer mod" : "Click to backup game";
mw.FinalizeInterfaceLoad();
/*
* if (!hasWorkingMEM)
* {
* await mw.ShowMessageAsync("Required components are not available",
* "Some components for installation are not available, likely due to network issues (blocking, no internet, etc). To install these components, folow the 'How to install the Installer Support Package' directions on any of the ALOT pages on NexusMods. The installer will not work without these files installed.",
* ContentWidthPercent: 75);
* }*/
PeriodicRefresh.OnPeriodicRefresh += MERPeriodicRefresh;
}
});
};
bw.RunWorkerCompleted += async(a, b) =>
{
// Post critical startup
Random random = new Random();
var preseed = random.Next();
window.ImageCredits.ReplaceAll(ImageCredit.LoadImageCredits("imagecredits.txt", false));
window.ContributorCredits.ReplaceAll(window.GetContributorCredits());
window.LibraryCredits.ReplaceAll(LibraryCredit.LoadLibraryCredits("librarycredits.txt"));
#if DEBUG
window.SeedTextBox.Text = 529572808.ToString();
#else
window.SeedTextBox.Text = preseed.ToString();
#endif
window.TextBlock_AssemblyVersion.Text = $"Version {App.AppVersion}";
window.SelectedRandomizeMode = MainWindow.RandomizationMode.ERandomizationMode_SelectAny;
var hasFirstRun = RegistryHandler.GetRegistrySettingBool(MainWindow.SETTING_FIRSTRUN);
if (hasFirstRun == null || !hasFirstRun.Value)
{
window.FirstRunFlyoutOpen = true;
}
await pd.CloseAsync();
};
bw.RunWorkerAsync();
}
public static byte[] ConvertTexture2D(ExportEntry export, MEGame newGame, List <int> offsets = null, StorageTypes newStorageType = StorageTypes.empty)
{
MemoryStream bin = export.GetReadOnlyBinaryStream();
if (bin.Length == 0)
{
return(bin.ToArray());
}
var os = new MemoryStream();
if (export.Game != MEGame.ME3)
{
bin.Skip(16);
}
if (newGame != MEGame.ME3)
{
os.WriteZeros(16);//includes fileOffset, but that will be set during save
}
int mipCount = bin.ReadInt32();
long mipCountPosition = os.Position;
os.WriteInt32(mipCount);
List <Texture2DMipInfo> mips = Texture2D.GetTexture2DMipInfos(export, export.GetProperty <NameProperty>("TextureFileCacheName")?.Value);
int offsetIdx = 0;
int trueMipCount = 0;
for (int i = 0; i < mipCount; i++)
{
var storageType = (StorageTypes)bin.ReadInt32();
int uncompressedSize = bin.ReadInt32();
int compressedSize = bin.ReadInt32();
int fileOffset = bin.ReadInt32();
byte[] texture;
switch (storageType)
{
case StorageTypes.pccUnc:
texture = bin.ReadToBuffer(uncompressedSize);
break;
case StorageTypes.pccLZO:
case StorageTypes.pccZlib:
texture = bin.ReadToBuffer(compressedSize);
if (offsets != null)
{
texture = Array.Empty <byte>();
fileOffset = offsets[offsetIdx++];
compressedSize = offsets[offsetIdx] - fileOffset;
if (newStorageType != StorageTypes.empty)
{
storageType = newStorageType;
}
}
break;
case StorageTypes.empty:
texture = new byte[0];
break;
default:
if (export.Game != newGame)
{
storageType &= (StorageTypes) ~StorageFlags.externalFile;
texture = Texture2D.GetTextureData(mips[i], export.Game, MEDirectories.GetDefaultGamePath(export.Game), false); //copy in external textures
}
else
{
texture = Array.Empty <byte>();
}
break;
}
int width = bin.ReadInt32();
int height = bin.ReadInt32();
if (newGame == MEGame.UDK && storageType == StorageTypes.empty)
{
continue;
}
trueMipCount++;
os.WriteInt32((int)storageType);
os.WriteInt32(uncompressedSize);
os.WriteInt32(compressedSize);
os.WriteInt32(fileOffset);//fileOffset will be fixed during save
os.WriteFromBuffer(texture);
os.WriteInt32(width);
os.WriteInt32(height);
}
long postMipPosition = os.Position;
os.JumpTo(mipCountPosition);
os.WriteInt32(trueMipCount);
os.JumpTo(postMipPosition);
int unk1 = 0;
if (export.Game != MEGame.UDK)
{
unk1 = bin.ReadInt32();
}
if (newGame != MEGame.UDK)
{
os.WriteInt32(unk1);
}
Guid textureGuid = export.Game != MEGame.ME1 ? bin.ReadGuid() : Guid.NewGuid();
if (newGame != MEGame.ME1)
{
os.WriteGuid(textureGuid);
}
if (export.Game == MEGame.UDK)
{
bin.Skip(32);
}
if (newGame == MEGame.UDK)
{
os.WriteZeros(4 * 8);
}
if (export.Game == MEGame.ME3)
{
bin.Skip(4);
}
if (newGame == MEGame.ME3)
{
os.WriteInt32(0);
}
if (export.ClassName == "LightMapTexture2D")
{
int lightMapFlags = 0;
if (export.Game >= MEGame.ME3)
{
lightMapFlags = bin.ReadInt32();
}
if (newGame >= MEGame.ME3)
{
os.WriteInt32(0);//LightMapFlags noflag
}
}
return(os.ToArray());
}