public LauncherWindow() { InitializeComponent(); launcherDirectory = Path.GetDirectoryName(PatchUtils.GetCurrentExecutablePath()); mainAppDirectory = Path.Combine(launcherDirectory, MAINAPP_SUBDIRECTORY); selfPatcherExecutablePath = Path.Combine(launcherDirectory, PatchParameters.SELF_PATCHER_DIRECTORY + Path.DirectorySeparatorChar + "SelfPatcher.exe"); patchNotesText.Text = string.Empty; statusText.Text = string.Empty; progressText.Text = string.Empty; progressBar.Value = 0; patchButton.Enabled = false; playButton.Click += (s, e) => PlayButtonClicked(); patchButton.Click += (s, e) => PatchButtonClicked(); repairButton.Click += (s, e) => RepairButtonClicked(); if (!string.IsNullOrEmpty(PATCH_NOTES_URL)) { FetchPatchNotes(); } if (!StartLauncherPatch()) { StartMainAppPatch(true); } }
private void xvmPathButton_Click(object sender, EventArgs e) { //convert actual newlines to "newlines" string newReg = Regex.Replace(xvmReplaceBox.Text, @"\n", "newline"); if (xvmPatchRB.Checked) { //PatchUtils.XVMPatch(xvmFilePathBox.Text, xvmPathBox.Text, xvmSearchBox.Text, newReg, XVMMode, "", "", true, xvmFilePathBox.Text); PatchUtils.XVMPatch(new Patch() { completePath = xvmFilePathBox.Text, path = xvmPathBox.Text, search = xvmSearchBox.Text, replace = newReg, mode = XVMMode }, true, xvmFilePathBox.Text); } else if (PMODPatchRB.Checked) { //PatchUtils.PMODPatch(xvmFilePathBox.Text, xvmPathBox.Text, xvmSearchBox.Text, newReg, XVMMode, "", "", true, xvmFilePathBox.Text); PatchUtils.PMODPatch(new Patch() { completePath = xvmFilePathBox.Text, path = xvmPathBox.Text, search = xvmSearchBox.Text, replace = newReg, mode = XVMMode }, true, xvmFilePathBox.Text); } else { //do nothing } }
static IEnumerable <CodeInstruction> Draw_Transpiler(IEnumerable <CodeInstruction> instructions) { return(PatchUtils.ReplaceColors(instructions, typeof(ShopMenu_Patches), new Dictionary <string, string> { { nameof(Color.Wheat), nameof(GetSelectedColor) }, { nameof(Color.Blue), nameof(GetQiSelectedColor) }, })); }
private void InitializePatcher() { patcher = SPTUtils.CreatePatcher(Path.GetDirectoryName(PatchUtils.GetCurrentExecutablePath()), versionInfoURL); if (!string.IsNullOrEmpty(versionInfoRSA)) { patcher.UseVersionInfoVerifier(( ref string xml ) => XMLSigner.VerifyXMLContents(xml, versionInfoRSA)); } if (!string.IsNullOrEmpty(patchInfoRSA)) { patcher.UsePatchInfoVerifier(( ref string xml ) => XMLSigner.VerifyXMLContents(xml, patchInfoRSA)); } // = checkVersionOnly = // true (default): only version number (e.g. 1.0) is compared against VersionInfo to see if there is an update // false: hashes and sizes of the local files are compared against VersionInfo (if there are any different/missing files, we'll patch the app) if (patcher.CheckForUpdates(checkVersionOnly)) { StartCoroutine(CheckForUpdatesCoroutine()); } else { Debug.LogError("Something went wrong"); } }
private static IEnumerable <CodeInstruction> Transpiler(IEnumerable <CodeInstruction> original) { var ins = original.ToList(); var propArray = ins.SkipWhile(x => !x.Calls(typeof(string).Method("Split"))).First(x => PatchUtils.IsLdLoc(x.opcode)); var endLabel = ins .SkipWhile(x => !x.Calls(typeof(ArrayList).Method("AddRange"))) .SkipWhile(x => x.opcode != OpCodes.Br).First().operand; var patched = false; foreach (var i in ins) { if (!patched && i.opcode == OpCodes.Ldarg_2) { patched = true; foreach (var e in PatchUtils.FireEvent(typeof(PropertyOperationEvent), false, new CodeInstruction(OpCodes.Ldarg_0), new CodeInstruction(OpCodes.Ldarg_1), new CodeInstruction(OpCodes.Ldarg_2), propArray )) { yield return(e); } yield return(new CodeInstruction(OpCodes.Brfalse, endLabel)); } yield return(i); } }
static IEnumerable <CodeInstruction> Draw_Transpiler(IEnumerable <CodeInstruction> instructions) { return(PatchUtils.ReplaceColors(instructions, typeof(MineElevatorMenu_Patches), new Dictionary <string, string> { { nameof(Color.Gray), nameof(GetCurrentFloorColor) }, { nameof(Color.Gold), nameof(GetFloorColor) }, })); }
private static void GetBuildablePrefix(TechType recipe) { if (CustomBuildables.Contains(recipe) && !CraftData.buildables.Contains(recipe)) { PatchUtils.PatchList(CraftData.buildables, CustomBuildables); } }
private void PatchResultButtonClicked() { if (Patcher.IsRunning) { Patcher.Cancel(); patcherButton.interactable = false; } //else if( patcher.Result == PatchResult.Failed ) //{ // patcher.Run( patcher.Operation == PatchOperation.SelfPatching ); // Initialize( patcher ); //} else if (Patcher.Result == PatchResult.Success && Patcher.Operation == PatchOperation.SelfPatching) { string selfPatcherPath = SPTUtils.SelfPatcherExecutablePath; if (!string.IsNullOrEmpty(selfPatcherPath) && File.Exists(selfPatcherPath)) { Patcher.ApplySelfPatch(selfPatcherPath, PatchUtils.GetCurrentExecutablePath()); } else { patchResultText.text = "Self patcher does not exist!"; } } else { Destroy(gameObject); } }
private void jsonPatchButton_Click(object sender, EventArgs e) { //PatchUtils.JSONPatch(jsonFilePathBox.Text, jsonPathBox.Text, jsonSearchBox.Text, jsonReplaceBox.Text, JSONMode, "", "", true, xvmFilePathBox.Text); PatchUtils.JSONPatch(new Patch() { completePath = jsonFilePathBox.Text, path = jsonPathBox.Text, search = jsonSearchBox.Text, replace = jsonReplaceBox.Text, mode = JSONMode }, true, xvmFilePathBox.Text); }
internal static void Patch() { // Direct access to private fields made possible by https://github.com/CabbageCrow/AssemblyPublicizer/ // See README.md for details. PatchUtils.PatchDictionary(BaseBioReactor.charge, CustomBioreactorCharges); Logger.Log("BaseBioReactorPatcher is done.", LogLevel.Debug); }
static IEnumerable <CodeInstruction> Draw_Transpiler(IEnumerable <CodeInstruction> instructions) { return(PatchUtils.ReplaceColors( instructions: instructions, type: typeof(CharacterCustomization_Patches), replacements: new Dictionary <string, string> { { nameof(Color.Red), nameof(GetErrorTextColor) } } )); }
static IEnumerable <CodeInstruction> Draw_Transpiler(IEnumerable <CodeInstruction> instructions) { return(PatchUtils.ReplaceColors( instructions: instructions, type: typeof(SpecialOrdersBoard_Patches), replacements: new Dictionary <string, string> { { nameof(Color.LightPink), nameof(GetHoverColor) } } )); }
static IEnumerable <CodeInstruction> DrawVersionMismatch_Transpiler(IEnumerable <CodeInstruction> instructions) { return(PatchUtils.ReplaceColors( instructions: instructions, type: typeof(LoadGameMenu_Patches), replacements: new Dictionary <string, string> { { nameof(Color.Red), nameof(GetErrorColor) } } )); }
static IEnumerable <CodeInstruction> Draw_Transpiler(IEnumerable <CodeInstruction> instructions) { return(PatchUtils.ReplaceColors( instructions: instructions, type: typeof(ExitPage_Patches), replacements: new Dictionary <string, string> { { nameof(Color.Wheat), nameof(GetHoverColor) } } )); }
private IEnumerator ExecutePatch() { patchButton.interactable = false; playButton.interactable = false; patcher.LogProgress(true); if (patcher.Run(isPatchingLauncher)) { Debug.Log("Executing patch..."); while (patcher.IsRunning) { FetchLogsFromPatcher(); yield return(null); } FetchLogsFromPatcher(); playButton.interactable = true; if (patcher.Result == PatchResult.AlreadyUpToDate) { // If launcher is already up-to-date, check if there is an update for the main app if (isPatchingLauncher) { StartMainAppPatch(true); } } else if (patcher.Result == PatchResult.Success) { // If patcher was self patching the launcher, start the self patcher executable // Otherwise, we have just updated the main app successfully! if (patcher.Operation == PatchOperation.SelfPatching) { string selfPatcherPath = SPTUtils.SelfPatcherExecutablePath; if (!string.IsNullOrEmpty(selfPatcherPath) && File.Exists(selfPatcherPath)) { patcher.ApplySelfPatch(selfPatcherPath, PatchUtils.GetCurrentExecutablePath()); } else { patcherLogText.text = "Self patcher does not exist!"; } } } else { // An error occurred, user can click the Patch button to try again patchButton.interactable = true; } } else { Debug.LogWarning("Operation could not be started; maybe it is already executing?"); } }
private void Awake() { launcherVersionInfoURL = launcherVersionInfoURL.Trim(); patchNotesURL = patchNotesURL.Trim(); forumURL = forumURL.Trim(); websiteURL = websiteURL.Trim(); versionInfoRSA = versionInfoRSA.Trim(); patchInfoRSA = patchInfoRSA.Trim(); patchNotesText.text = ""; patcherLogText.text = ""; patcherProgressText.text = ""; patcherProgressbar.value = 0; patcherOverallProgressbar.value = 0; forumButton.onClick.AddListener(ForumButtonClicked); websiteButton.onClick.AddListener(WebsiteButtonClicked); launcherDirectory = Path.GetDirectoryName(PatchUtils.GetCurrentExecutablePath()); gamesDirectory = Path.Combine(launcherDirectory, gamesSubdirectory); selfPatcherPath = PatchUtils.GetDefaultSelfPatcherExecutablePath(selfPatcherExecutable); string currentVersion = PatchUtils.GetCurrentAppVersion(); versionCodeText.text = string.IsNullOrEmpty(currentVersion) ? "" : ("v" + currentVersion); gameHolders = new MultiGameLauncherGameHolder[games.Length]; for (int i = 0; i < games.Length; i++) { games[i].TrimLinks(); MultiGameLauncherGameHolder gameHolder = (MultiGameLauncherGameHolder)Instantiate(gameHolderPrefab, gameHolderParent, false); gameHolder.Initialize(games[i]); gameHolder.OnPlayButtonClicked += PlayButtonClicked; gameHolder.OnPatchButtonClicked += PatchButtonClicked; gameHolder.PlayButtonSetEnabled(File.Exists(Path.Combine(gamesDirectory, games[i].ExecutablePath))); gameHolders[i] = gameHolder; StartCoroutine(CheckForUpdates(gameHolder)); } // To resolve a Unity bug gamesPanel.gameObject.SetActive(false); gamesPanel.gameObject.SetActive(true); if (!string.IsNullOrEmpty(patchNotesURL)) { StartCoroutine(FetchPatchNotes()); } // Can't test the launcher on Editor #if !UNITY_EDITOR StartLauncherPatch(); #endif }
static IEnumerable <CodeInstruction> Draw_Transpiler(IEnumerable <CodeInstruction> instructions) { return(PatchUtils.ReplaceColors( instructions: instructions, type: typeof(MoneyDial_Patches), replacements: new Dictionary <string, string> { { nameof(Color.Gold), nameof(GetSparkleColor) }, { nameof(Color.Maroon), nameof(GetMoneyColor) } } )); }
private static void Initialize() { PatcherEditor window = GetWindow <PatcherEditor>(); window.titleContent = new GUIContent("Patcher"); window.minSize = new Vector2(300f, 275f); window.c_Name = PatchUtils.IsProjectNameValid(Application.productName) ? Application.productName : "MyProject"; window.c_Version = Application.version; window.Show(); }
static IEnumerable <CodeInstruction> Draw_Transpiler(IEnumerable <CodeInstruction> instructions) { return(PatchUtils.ReplaceColors( instructions: instructions, type: typeof(CarpenterMenu_Patches), replacements: new Dictionary <string, string> { { nameof(Color.Red), nameof(GetErrorTextColor) }, { nameof(Color.PaleGoldenrod), nameof(GetMagicTextColor) }, { nameof(Color.RoyalBlue), nameof(GetMagicBackgroundColor) }, } )); }
static IEnumerable <CodeInstruction> Draw_Transpiler(IEnumerable <CodeInstruction> instructions) { return(PatchUtils.ReplaceColors( instructions: instructions, type: typeof(OptionsDropDown_Patches), replacements: new Dictionary <string, string> { { nameof(Color.Wheat), nameof(GetHoverColor) }, }, fieldReplacements: new Dictionary <string, string> { { nameof(Game1.textColor), nameof(GetTextColor) }, }.HydrateFieldKeys(typeof(Game1)).HydrateMethodValues(typeof(OptionsDropDown_Patches)) )); }
internal static void PrePatch(Harmony harmony) { PatchUtils.PatchClass(harmony); #if !SUBNAUTICA_STABLE // patching iterator method ProtobufSerializer.DeserializeObjectsAsync MethodInfo DeserializeObjectsAsync = typeof(ProtobufSerializer).GetMethod( nameof(ProtobufSerializer.DeserializeObjectsAsync), BindingFlags.NonPublic | BindingFlags.Instance); harmony.Patch(PatchUtils.GetIteratorMethod(DeserializeObjectsAsync), transpiler: new HarmonyMethod(AccessTools.Method(typeof(PrefabDatabasePatcher), nameof(DeserializeObjectsAsync_Transpiler)))); #endif Logger.Log("PrefabDatabasePatcher is done.", LogLevel.Debug); }
static IEnumerable <CodeInstruction> Draw_Transpiler(IEnumerable <CodeInstruction> instructions) { return(PatchUtils.ReplaceColors( instructions: instructions, type: typeof(DayTimeMoneyBox_Patches), replacements: new Dictionary <string, string> { { nameof(Color.Red), nameof(GetAfterMidnightColor) } }, fieldReplacements: new Dictionary <string, string> { { nameof(Game1.textColor), nameof(GetTextColor) } }.HydrateFieldKeys(typeof(Game1)).HydrateMethodValues(typeof(DayTimeMoneyBox_Patches)) )); }
private void ExecutePatch() { StartThread(() => { ButtonSetEnabled(patchButton, false); ButtonSetEnabled(playButton, false); patcher.LogProgress(true); if (patcher.Run(isPatchingLauncher)) { while (patcher.IsRunning) { FetchLogsFromPatcher(); Thread.Sleep(500); } FetchLogsFromPatcher(); ButtonSetEnabled(playButton, true); if (patcher.Result == PatchResult.AlreadyUpToDate) { // If launcher is already up-to-date, check if there is an update for the main app if (isPatchingLauncher) { StartMainAppPatch(true); } } else if (patcher.Result == PatchResult.Success) { // If patcher was self patching the launcher, start the self patcher executable // Otherwise, we have just updated the main app successfully! if (patcher.Operation == PatchOperation.SelfPatching) { if (!string.IsNullOrEmpty(selfPatcherExecutablePath) && File.Exists(selfPatcherExecutablePath)) { patcher.ApplySelfPatch(selfPatcherExecutablePath, PatchUtils.GetCurrentExecutablePath()); } else { UpdateLabel(progressText, "Self patcher does not exist!"); } } } else { // An error occurred, user can click the Patch button to try again ButtonSetEnabled(patchButton, true); } } }); }
static IEnumerable <CodeInstruction> Draw_Transpiler(IEnumerable <CodeInstruction> instructions) { return(PatchUtils.ReplaceColors( instructions: instructions, type: typeof(SkillsPage_Patches), replacements: new Dictionary <string, string> { { nameof(Color.LightGreen), nameof(GetModifiedNumberColor) }, { nameof(Color.SandyBrown), nameof(GetNumberColor) } }, fieldReplacements: new Dictionary <string, string> { { nameof(Game1.textColor), nameof(GetTextColor) } }.HydrateFieldKeys(typeof(Game1)).HydrateMethodValues(typeof(SkillsPage_Patches)) )); }
internal static void Patch(Harmony harmony) { PatchUtils.PatchClass(harmony); PatchUtils.PatchClass(harmony, typeof(ScrollPosKeeper)); if (QModServices.Main.FindModById("ModsOptionsAdjusted")?.Enable == true) { V2.Logger.Log("ModOptionsAdjuster is not inited (ModsOptionsAdjusted mod is active)", LogLevel.Warn); } else { PatchUtils.PatchClass(harmony, typeof(ModOptionsHeadingsToggle)); } }
static IEnumerable <CodeInstruction> CraftingRecipe_drawDescription_Transpiler(IEnumerable <CodeInstruction> instructions) { return(PatchUtils.ReplaceColors( instructions: instructions, type: typeof(IClickableMenu_Patches), replacements: new Dictionary <string, string> { { nameof(Color.Red), nameof(GetInsufficientColor) } }, fieldReplacements: new Dictionary <string, string> { { nameof(Game1.textColor), nameof(GetTextColor) }, { nameof(Game1.textShadowColor), nameof(GetShadowColor) } }.HydrateFieldKeys(typeof(Game1)).HydrateMethodValues(typeof(IClickableMenu_Patches)) )); }
static IEnumerable <CodeInstruction> DrawHoverText_Transpiler(IEnumerable <CodeInstruction> instructions) { return(PatchUtils.ReplaceColors( instructions: instructions, type: typeof(IClickableMenu_Patches), replacements: new Dictionary <string, string> { { nameof(Color.DimGray), nameof(GetForgeCountTextColor) }, { nameof(Color.DarkRed), nameof(GetForgedTextColor) } }, fieldReplacements: new Dictionary <string, string> { { nameof(Game1.textColor), nameof(GetTextColor) }, { nameof(Game1.textShadowColor), nameof(GetShadowColor) } }.HydrateFieldKeys(typeof(Game1)).HydrateMethodValues(typeof(IClickableMenu_Patches)) )); }
static IEnumerable <CodeInstruction> Draw_Transpiler(IEnumerable <CodeInstruction> instructions) { return(PatchUtils.ReplaceColors( instructions, typeof(Billboard_Patches), new Dictionary <string, string> { { nameof(Color.Gray), nameof(GetDimColor) }, { nameof(Color.Blue), nameof(GetTodayColor) }, { nameof(Color.LightPink), nameof(GetHoverColor) }, }, fieldReplacements: new Dictionary <string, string> { { nameof(Game1.textColor), nameof(GetTextColor) } }.HydrateFieldKeys(typeof(Game1)).HydrateMethodValues(typeof(Billboard_Patches)) )); }
private static void DictionaryPrefix <T>(TechType techType, IDictionary <TechType, T> smlCollection, IDictionary <TechType, T> craftDataCollection) { if (smlCollection.TryGetValue(techType, out T sml)) { if (craftDataCollection.TryGetValue(techType, out T gameVal)) { if (!sml.Equals(gameVal)) { craftDataCollection[techType] = sml; } } else { PatchUtils.PatchDictionary(craftDataCollection, smlCollection); } } }
public void RunSelfPatcherExecutable() { if (!IsSelfPatchingApp) { return; } #if UNITY_EDITOR Debug.LogError("Can't self patch while testing on editor"); #else string postSelfPatchExecutable = RestartAppAfterSelfPatching ? PatchUtils.GetCurrentExecutablePath() : null; if (!Patcher.ApplySelfPatch(PatchUtils.GetDefaultSelfPatcherExecutablePath(SelfPatcherExecutable), postSelfPatchExecutable)) { Debug.LogError("Patcher is already running or something went wrong"); } #endif }