Patchless

Marsey/Config/MarseyConf.cs

@@ -74,6 +74,11 @@ public static class MarseyConf
     /// </summary>
     public static bool DisableAnyBackports;
 
+    /// <summary>
+    /// Don't run any patches
+    /// </summary>
+    public static bool Patchless;
+
     /// <summary>
     /// Reflect changes made here to the Dictionary in the launcher's Connector.cs
     /// </summary>
@@ -97,7 +102,8 @@ public static class MarseyConf
         { "MARSEY_NO_ANY_BACKPORTS", value => DisableAnyBackports = value == "true" },
         { "MARSEY_FORKID", MarseyPortMan.SetForkID },
         { "MARSEY_ENGINE", MarseyPortMan.SetEngineVer },
-        { "MARSEY_HIDE_LEVEL", value => MarseyHide = (HideLevel)Enum.Parse(typeof(HideLevel), value) }
+        { "MARSEY_HIDE_LEVEL", value => MarseyHide = (HideLevel)Enum.Parse(typeof(HideLevel), value) },
+        { "MARSEY_PATCHLESS", value => Patchless = value == "true"}
     };
 
     // Conf variables that do not go into the EnvVarMap go here

Marsey/Game/Patcher.cs

@@ -7,6 +7,7 @@
 using Marsey.Game.Misc;
 using Marsey.Patches;
 using Marsey.Misc;
+using Marsey.Stealthsey.Reflection;
 
 namespace Marsey.Game;
 
@@ -25,9 +26,10 @@ public static void Patch<T>(List<T> patchlist) where T : IPatch
             PatchAssembly(harmony, patch);
         }
     }
-    
+
     /// <inheritdoc cref="Patcher.Patch"/>
-    private static void PatchAssembly<T>(Harmony harmony, T patch) where T : IPatch
+    [Patching]
+    private static void PatchAssembly(Harmony harmony, IPatch patch)
     {
         AssemblyName assemblyName = patch.Asm.GetName();
         MarseyLogger.Log(MarseyLogger.LogType.INFO, $"Patching {assemblyName}");
@@ -56,4 +58,4 @@ private static void HandlePatchException(string assemblyName, Exception e)
 
         MarseyLogger.Log(MarseyLogger.LogType.FATL, errorMessage);
     }
-}
+}

Marsey/Game/Patches/Marseyports/MarseyPortMan.cs

@@ -5,6 +5,7 @@
 using Marsey.Game.Patches.Marseyports.Attributes;
 using Marsey.Misc;
 using Marsey.Stealthsey;
+using Marsey.Stealthsey.Reflection;
 
 namespace Marsey.Game.Patches.Marseyports;
 
@@ -66,6 +67,7 @@ private static bool ValidateBackport(Type backport)
         return true;
     }
 
+    [Patching]
     public static void PatchBackports(bool Content = false)
     {
         if (_backports == null) return;

Marsey/Handbreak/Helpers.cs

@@ -18,7 +18,7 @@ public static class Helpers
         Type? t = TypeFromQualifiedName(FullyQualifiedTypeName);
 
         if (t != null) return GetMethod(t, MethodName, parameters);
-        
+
         MarseyLogger.Log(MarseyLogger.LogType.ERRO, $"{FullyQualifiedTypeName} not found.");
         return null;
     }
@@ -30,7 +30,7 @@ public static class Helpers
     {
         return AccessTools.Method(type, MethodName, parameters);
     }
-    
+
     /// <summary>
     /// Patches a method from the given pointers
     /// </summary>
@@ -44,14 +44,15 @@ public static class Helpers
     public static void PatchMethod(Type? targetType, string targetMethodName, Type? patchType, string patchMethodName, HarmonyPatchType patchingType, Type[]? targetMethodParameters = null, Type[]? patchMethodParameters = null)
     {
         ValidateTypes(targetType, patchType);
-        
+
         MethodInfo? targetMethod = GetAndValidateMethod(targetType, targetMethodName, targetMethodParameters, "target");
         MethodInfo? patchMethod = GetAndValidateMethod(patchType, patchMethodName, patchMethodParameters, "patch");
 
         if (Manual.Patch(targetMethod, patchMethod, patchingType))
             LogPatchSuccess(patchingType, targetMethodName, patchMethodName);
     }
 
+    #region Generics
     public static void PatchGenericMethod(Type? targetType, string targetMethodName, Type? patchType, string patchMethodName, Type returnType, HarmonyPatchType patchingType)
     {
         ValidateTypes(targetType, patchType);
@@ -60,26 +61,50 @@ public static void PatchGenericMethod(Type? targetType, string targetMethodName,
         MethodInfo? patchMethod = GetAndValidateMethod(patchType, patchMethodName, null, "patch");
 
         MethodInfo? genericMethod = MakeGenericMethod(patchMethod, returnType);
-        
+
         if (Manual.Patch(targetMethod, genericMethod, patchingType))
             LogPatchSuccess(patchingType, targetMethodName, patchMethodName);
     }
 
-    public static void PatchGenericMethod(MethodInfo? target, MethodInfo? patch, Type returnType, HarmonyPatchType patchType)
+    public static void PatchGenericMethod(MethodInfo? target, Type targetReturnType, MethodInfo? patch, Type patchReturnType, HarmonyPatchType patchType)
+    {
+        target = MakeGenericMethod(target, targetReturnType);
+        patch = MakeGenericMethod(patch, patchReturnType);
+
+        if (Manual.Patch(target, patch, patchType))
+            LogPatchSuccess(patchType, target!.Name, patch!.Name);
+    }
+
+    public static void PatchGenericMethod(MethodInfo? target, MethodInfo? patch, Type patchReturnType, HarmonyPatchType patchType)
+    {
+        patch = MakeGenericMethod(patch, patchReturnType);
+
+        if (Manual.Patch(target, patch, patchType))
+            LogPatchSuccess(patchType, target!.Name, patch!.Name);
+    }
+
+    public static void PatchGenericMethod(MethodInfo target, Type targetReturnType, MethodInfo? patch, HarmonyPatchType patchType)
     {
-        MethodInfo? generic = MakeGenericMethod(patch, returnType);
-
-        if (Manual.Patch(target, generic, patchType))
+        target = target.MakeGenericMethod([]);
+
+        if (Manual.Patch(target, patch, patchType))
+            LogPatchSuccess(patchType, target.Name, patch!.Name);
+    }
+
+    public static void PatchGenericMethod(MethodInfo? target, MethodInfo? patch, HarmonyPatchType patchType)
+    {
+        if (Manual.Patch(target, patch, patchType))
             LogPatchSuccess(patchType, target!.Name, patch!.Name);
-
     }
-
+
+    #endregion
+
     private static void ValidateTypes(Type? targetType, Type? patchType)
     {
         if (targetType == null || patchType == null)
             throw new HandBreakException($"Passed type is null. Target: {targetType}, patch: {patchType}");
     }
-    
+
     private static void ValidateMethods(MethodInfo? target, MethodInfo? patch)
     {
         if (target == null || patch == null)
@@ -97,7 +122,7 @@ private static void ValidateMethods(MethodInfo? target, MethodInfo? patch)
     private static MethodInfo? MakeGenericMethod(MethodInfo? method, Type returnType)
     {
         if (method != null) return method.MakeGenericMethod(returnType);
-        
+
         MarseyLogger.Log(MarseyLogger.LogType.ERRO, "Handbreak", $"Error making generic method");
         return null;
     }
@@ -106,4 +131,4 @@ private static void LogPatchSuccess(HarmonyPatchType patchingType, string target
     {
         MarseyLogger.Log(MarseyLogger.LogType.DEBG, "Handbreak", $"{patchingType}: Patched {targetMethodName} with {patchMethodName}.");
     }
-}
+}

Marsey/MarseyPatcher.cs

@@ -15,6 +15,7 @@
 using Marsey.Stealthsey;
 using Marsey.Subversion;
 using Marsey.Misc;
+using Marsey.Stealthsey.Reflection;
 
 namespace Marsey;
 
@@ -63,7 +64,7 @@ private MarseyPatcher(Assembly? robClientAssembly, ManualResetEvent mre)
         Utility.ReadConf();
         HarmonyManager.Init(new Harmony(MarseyVars.Identifier));
 
-        MarseyLogger.Log(MarseyLogger.LogType.INFO, $"Marseyloader started, version {MarseyVars.MarseyVersion}");
+        MarseyLogger.Log(MarseyLogger.LogType.INFO, $"Marseyloader started{(MarseyConf.Patchless ? " in patchless mode" : "")}, version {MarseyVars.MarseyVersion}");
 
         // Init backport manager
         MarseyPortMan.Initialize();
@@ -78,7 +79,8 @@ private MarseyPatcher(Assembly? robClientAssembly, ManualResetEvent mre)
     }
 
     // We might want to patch things before the loader has even a chance to execute anything
-    public void Preload()
+    [Patching]
+    private void Preload()
     {
         Sentry.Patch();
 

Marsey/Stealthsey/Hidesey.cs

@@ -73,7 +73,7 @@ public static void Initialize() // Finally, a patch loader that loads with a pat
 
         _initialized = true;
 
-        HideLevelExec.Initialize();
+        HideseyAttributeManager.Initialize();
 
         Load();
     }
@@ -203,7 +203,7 @@ private static void Perjurize()
             Helpers.PatchGenericMethod(
                 target: targetMethod,
                 patch: Lie,
-                returnType: returnType,
+                patchReturnType: returnType,
                 patchType: HarmonyPatchType.Postfix
             );
         }

Marsey/Stealthsey/HideseyPatches.cs

@@ -34,6 +34,8 @@ public static void Lie<T>(ref T __result)
     /// </summary>
     public static bool Skip() => false;
 
+    public static bool SkipPatchless() => !MarseyConf.Patchless;
+
     /// <summary>
     /// Prefix patch that checks if MarseyHide matches or above the attributed HideLevelRequirement
     /// </summary>

Marsey/Stealthsey/Reflection/HideLevelExec.cs → Marsey/Stealthsey/Reflection/HideseyAttributeManager.cs

@@ -12,7 +12,7 @@ namespace Marsey.Stealthsey.Reflection;
 /// <summary>
 /// Manages methods with the HideLevelRequirement attribute, patching them with a prefix.
 /// </summary>
-public static class HideLevelExec
+public static class HideseyAttributeManager
 {
     /// <summary>
     /// Initializes the HideLevelExec by finding and patching methods with HideLevelRequirement attributes.
@@ -21,40 +21,55 @@ public static void Initialize()
     {
         Assembly assembly = Assembly.GetExecutingAssembly();
         IEnumerable<Type> types = assembly.GetTypes();
-        
-        IEnumerable<Type> marseyTypes = types.Where(t => t.Namespace != null && t.Namespace.StartsWith("Marsey"));
-        
+
+        IEnumerable<Type> marseyTypes = Assembly.GetExecutingAssembly().ExportedTypes;
+
         foreach (Type type in marseyTypes)
         {
             CheckAndExecute(type);
         }
     }
-    
+
     /// <summary>
     /// Checks each type for methods with HideLevelRequirement attributes and executes them if the hide level is met.
     /// </summary>
     private static void CheckAndExecute(Type type)
     {
         // Get all methods from the given type
-        IEnumerable<MethodInfo> methods = type.GetMethods(BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Public | BindingFlags.Instance);
+        IEnumerable<MethodInfo> methods = AccessTools.GetDeclaredMethods(type);
 
         foreach (MethodInfo method in methods)
         {
-            ExecIfLevelMet(method);
+            SetExecLevels(method);
+            SetPatchless(method);
         }
     }
-    
+
     /// <summary>
     /// Executes the method if the current hide level meets or exceeds the required level specified by the HideLevelRequirement attribute.
     /// </summary>
-    private static void ExecIfLevelMet(MethodInfo method)
+    private static void SetExecLevels(MethodInfo method)
     {
         HideLevelRequirement? hideLevelRequirement = method.GetCustomAttribute<HideLevelRequirement>();
         HideLevelRestriction? hideLevelRestriction = method.GetCustomAttribute<HideLevelRestriction>();
 
         if (hideLevelRequirement == null && hideLevelRestriction == null) return;
-        
+
         MethodInfo? prefix = typeof(HideseyPatches).GetMethod("LevelCheck", BindingFlags.Public | BindingFlags.Static);
         Manual.Patch(method, prefix, HarmonyPatchType.Prefix);
     }
-}
+
+    private static void SetPatchless(MethodInfo method)
+    {
+        if (method.GetCustomAttribute<Patching>() is null) return;
+        if (method.IsGenericMethod) throw new InvalidOperationException("Patching attribute not allowed on generic methods.");
+
+        Console.WriteLine($"Trying to patch {method.Name}");
+
+        MethodInfo? prefix = AccessTools.Method(typeof(HideseyPatches), nameof(HideseyPatches.SkipPatchless));
+
+        Manual.Patch(method, prefix, HarmonyPatchType.Prefix);
+
+        Console.WriteLine($"Patched {method.Name} fine");
+    }
+}

Marsey/Stealthsey/Reflection/PatchingAttribute.cs

@@ -0,0 +1,10 @@
+using System.Reflection;
+
+namespace Marsey.Stealthsey.Reflection;
+
+/// <summary>
+/// Method is patching the game in some form
+/// <remarks> Does not execute if <see cref="Patching"/> is true </remarks>
+/// </summary>
+[AttributeUsage(AttributeTargets.Method, Inherited = false)]
+public sealed class Patching : Attribute;

Marsey/Subversion/Subverse.cs

@@ -32,6 +32,7 @@ public static bool CheckSubversions()
     /// This is done as we attach to the assembly loading function
     /// </summary>
     [HideLevelRestriction(HideLevel.Unconditional)]
+    [Patching]
     public static void PatchSubverter()
     {
 

SS14.Launcher/Models/Connector.cs

@@ -611,7 +611,8 @@ private void ConfigureMarsey()
             { "MARSEY_BACKPORTS", _cfg.GetCVar(CVars.Backports) ? "true" : null },
             { "MARSEY_NO_ANY_BACKPORTS", _cfg.GetCVar(CVars.DisableAnyEngineBackports) ? "true" : null },
             { "MARSEY_DISABLE_STRICT", _cfg.GetCVar(CVars.DisableStrict) ? "true" : null },
-            { "MARSEY_DUMP_ASSEMBLIES", MarseyConf.Dumper ? "true" : null }
+            { "MARSEY_DUMP_ASSEMBLIES", MarseyConf.Dumper ? "true" : null },
+            { "MARSEY_PATCHLESS", _cfg.GetCVar(CVars.Patchless) ? "true" : null }
         };
 
         // Serialize environment variables

SS14.Launcher/Models/Data/CVars.cs

@@ -259,6 +259,11 @@ public static readonly CVarDef<bool> HasDismissedEarlyAccessWarning
     /// Username used in guest mode
     /// </summary>
     public static readonly CVarDef<string> GuestUsername = CVarDef.Create("GuestUsername", "Guest");
+
+    /// <summary>
+    /// Do not patch anything in the game modules
+    /// </summary>
+    public static readonly CVarDef<bool> Patchless = CVarDef.Create("Patchless", false);
 }
 
 /// <summary>

SS14.Launcher/ViewModels/MainWindowTabs/OptionsTabViewModel.cs

@@ -499,6 +499,16 @@ public bool DumpAssemblies
         set => MarseyConf.Dumper = value;
     }
 
+    public bool Patchless
+    {
+        get => Cfg.GetCVar(CVars.Patchless);
+        set
+        {
+            Cfg.SetCVar(CVars.Patchless, value);
+            Cfg.CommitConfig();
+        }
+    }
+
     public bool ResourceOverride
     {
         get => Cfg.GetCVar(CVars.DisableStrict);

SS14.Launcher/Views/MainWindowTabs/OptionsTabView.xaml

@@ -251,6 +251,11 @@
       <ScrollViewer HorizontalScrollBarVisibility="Disabled">
         <DockPanel>
           <StackPanel Orientation="Vertical">
+            <CheckBox VerticalAlignment="Center" Margin="4" IsChecked="{Binding Patchless}">Run patchless</CheckBox>
+            <TextBlock VerticalAlignment="Center" TextWrapping="Wrap"
+                       Text="Disables any patching except hiding harmony, essentially acting like a killswitch. Useful when game breaks due to the launcher itself."
+                       Margin="8" />
+
             <TextBlock Margin="4, 0" Text="Patches" Classes="NanoHeadingMedium" />
             <CheckBox VerticalAlignment="Center" Margin="4" IsChecked="{Binding DumpAssemblies}">Dump Resources</CheckBox>
             <TextBlock VerticalAlignment="Center" TextWrapping="Wrap"