added dumper tool as it was in the old tool, to branch and convert

ReCodeItCLI/Commands/Dumper.cs

@@ -9,13 +9,8 @@ namespace ReCodeIt.Commands;
 [Command("Dumper", Description = "Generates a dumper zip")]
 public class Dumper : ICommand
 {
-    [CommandParameter(0, IsRequired = true, Description = "The absolute path to your DeObfuscated assembly file, folder must contain all references to be resolved.")]
+    [CommandParameter(0, IsRequired = true, Description = "The absolute path to your Managed folder for EFT, folder must contain all references to be resolved.")]
-    public string GameAssemblyPath { get; init; }
+    public string ManagedDirectory { get; init; }
-    
-    [CommandParameter(1, IsRequired = true, Description = "The absolute path to your FileChecker.dll file, folder must contain all refgerences to be resolved.")]
-    public string CheckerAssemblyPath { get; init; }
-    
-    private Dumpy _dumpy { get; set; }
     
     public ValueTask ExecuteAsync(IConsole console)
     {
@@ -23,10 +18,8 @@ public class Dumper : ICommand
         DataProvider.LoadAppSettings();
         
         Logger.Log("Creating Dumper...");
-
+        
-        _dumpy = new Dumpy(GameAssemblyPath, CheckerAssemblyPath, Path.GetDirectoryName(GameAssemblyPath));
+        ReCodeItLib.Dumper.Dumper.CreateDumper(ManagedDirectory);
-        _dumpy.CreateDumpFolders();
-        _dumpy.CreateDumper();
         
         Logger.Log("Complete", ConsoleColor.Green);
         

RecodeItLib/Dumper/Dumper.cs

@@ -0,0 +1,338 @@
+using Mono.Cecil;
+using Mono.Cecil.Cil;
+using ReCodeIt.Utils;
+
+namespace ReCodeItLib.Dumper;
+
+public class Dumper
+{
+    public static void CreateDumper(string managedPath)
+    {
+        var resolver = new DefaultAssemblyResolver();
+        resolver.AddSearchDirectory(managedPath);
+
+        // remove these dirs so it resolves to managed folder only
+        resolver.RemoveSearchDirectory(".");
+        resolver.RemoveSearchDirectory("bin");
+
+        var readerParameters = new ReaderParameters { AssemblyResolver = resolver };
+
+        // Assembly-CSharp section
+        var assemblyPath = Path.Combine(managedPath, "Assembly-Csharp.dll");
+        var dumperOutputPath = Path.Combine(managedPath, "dumper");
+        var dumperBackupPath = Path.Combine(dumperOutputPath, "backup");
+        var dumperDataFolder = Path.Combine(dumperOutputPath, "DUMPDATA");
+        var newAssemblyPath = Path.Combine(dumperOutputPath, "Assembly-CSharp.dll");
+
+        Directory.CreateDirectory(dumperOutputPath);
+        Directory.CreateDirectory(dumperBackupPath);
+        Directory.CreateDirectory(dumperDataFolder);
+
+        File.Copy(Path.Combine(managedPath, "Assembly-CSharp.dll"), Path.Combine(dumperBackupPath, "Assembly-CSharp.dll"), true);
+        File.Copy(Path.Combine(managedPath, "FilesChecker.dll"), Path.Combine(dumperBackupPath, "FilesChecker.dll"), true);
+        File.Copy(".\\Assets\\Dumper\\DumpLib.dll", Path.Combine(dumperOutputPath, "DumpLib.dll"), true);
+        File.Copy(".\\Assets\\Dumper\\DUMPDATA\\botReqData.json", dumperDataFolder + "\\botreqData.json", true);
+        File.Copy(".\\Assets\\Dumper\\DUMPDATA\\config.json", dumperDataFolder + "\\config.json", true);
+        File.Copy(".\\Assets\\Dumper\\DUMPDATA\\raidSettings.json", dumperDataFolder + "\\raidSettings.json", true);
+
+        // loads assembly
+        var oldAssembly = AssemblyDefinition.ReadAssembly(assemblyPath, readerParameters);
+
+        // gets all types
+        var types = oldAssembly.MainModule.GetTypes().ToList();
+
+        // finds and checks for type with backRequest
+        var backRequestType = types.Where(DumpyTypeHelper.GetBackRequestType).ToList();
+        CheckNullOrMulti(backRequestType, "BackRequest");
+
+        // finds and checks for type with ValidateCertificate
+        var validateCertificateType = types.Where(DumpyTypeHelper.GetValidateCertificateType).ToList();
+        CheckNullOrMulti(validateCertificateType, "ValidateCertificate");
+
+        // finds and checks for type with RunValidation
+        var runValidationType = types.Where(DumpyTypeHelper.GetRunValidationType).ToList();
+        CheckNullOrMulti(runValidationType, "RunValidation");
+
+        var dumpyTaskType = types.Where(DumpyTypeHelper.GetMenuScreenType).ToList();
+        CheckNullOrMulti(dumpyTaskType, "DumpyTask");
+
+        // apply code changes
+        SetBackRequestCode(oldAssembly, backRequestType[0]);
+        SetValidateCertificateCode(validateCertificateType[0]);
+        SetRunValidationCode(oldAssembly, runValidationType[0]);
+        SetDumpyTaskCode(oldAssembly, dumpyTaskType[0]);
+
+        // write modified assembly to file
+        oldAssembly.Write(newAssemblyPath);
+
+        // FilesChecker section
+        var oldFilesCheckerPath = Path.Combine(managedPath, "FilesChecker.dll");
+        var oldFilesChecker = AssemblyDefinition.ReadAssembly(oldFilesCheckerPath, readerParameters);
+        var newFilesCheckerPath = Path.Combine(dumperOutputPath, Path.GetFileName(oldFilesCheckerPath));
+
+        // gets all types
+        types = oldFilesChecker.MainModule.GetTypes().ToList();
+
+        // finds and checks for type called EnsureConsistency
+        var ensureConsistencyType = types.Where(DumpyTypeHelper.GetEnsureConsistencyType).ToList();
+        CheckNullOrMulti(ensureConsistencyType, "EnsureConsistency");
+
+        // apply code changes
+        SetEnsureConsistencyCode(oldFilesChecker, ensureConsistencyType[0]);
+        SetEnsureConsistencySingleCode(oldFilesChecker, ensureConsistencyType[0]);
+
+        // Write modified assembly to file
+        oldFilesChecker.Write(newFilesCheckerPath);
+    }
+
+    /// <summary>
+    /// <para>Finds the method with backRequest and bResponse as params.</para>
+    /// <para>Checks the method instructions before modification has a count of 269,</para>
+    /// <para>if this is not the case, this needs to be checked.</para>
+    /// <para>This type passed in is the only type with this method.</para>
+    /// </summary>
+    /// <param name="oldAssembly"></param>
+    /// <param name="type"></param>
+    private static void SetBackRequestCode(AssemblyDefinition oldAssembly, TypeDefinition type)
+    {
+        // find method
+        var method = type.Methods.First(x =>
+            x.Parameters.Any(p => p.Name is "backRequest") && x.Parameters.Any(p => p.Name == "bResponse"));
+
+        if (method == null || method.Body.Instructions.Count != 269)
+        {
+            Logger.Log($"BackRequest Instructions count has changed from 269 to {method.Body.Instructions.Count}", ConsoleColor.Red);
+        }
+
+        // where we insert the new instructions
+        var startOfInstructions = 252;
+
+        var processor = method.Body.GetILProcessor();
+
+        var liList = DumpyInstructionsHelper.GetBackRequestInstructions(oldAssembly, method);
+
+        var index = method.Body.Instructions[startOfInstructions];
+
+        foreach (var item in liList)
+        {
+            processor.InsertBefore(index, item);
+        }
+
+        var ins = Instruction.Create(OpCodes.Brfalse_S, method.Body.Instructions[startOfInstructions]); // create instruction to jump to index 252
+
+        method.Body.Instructions[220] = ins; // instruction to jump from 202 to 252
+    }
+
+    /// <summary>
+    /// <para>Finds the method called ValidateCertificate.</para>
+    /// <para>Checks that we found two of these methods,</para>
+    /// <para>if this is not the case, this needs to be checked.</para>
+    /// <para>This type passed in is the only type with this method.</para>
+    /// </summary>
+    /// <param name="oldAssembly"></param>
+    /// <param name="type"></param>
+    private static void SetValidateCertificateCode(TypeDefinition type)
+    {
+        var methods = type.Methods.Where(x =>
+            x.Name == "ValidateCertificate"); // should be 2
+
+        // check make sure nothing has changed
+        var firstMethod = methods.FirstOrDefault(m => m.Parameters.Any(p => p.Name == "certificate"));
+        var secondMethod = methods.FirstOrDefault(m => m.Parameters.Any(p => p.Name == "certificateData"));
+
+        if (firstMethod?.Body.Instructions.Count != 55 || secondMethod?.Body.Instructions.Count != 14)
+        {
+            var errorMessage =
+                $"Instruction count has changed, method with 'certificate' as a param - before: 51, now: {firstMethod.Body.Instructions.Count}, " +
+                $"method with 'certificateData' as a param - before: 14, now: {secondMethod.Body.Instructions.Count}";
+            Logger.Log(errorMessage, ConsoleColor.Red);
+        }
+
+        if (methods.Count() != 2)
+        {
+            Logger.Log($"ValidateCertificate should be found twice, count was: {methods.Count()}", ConsoleColor.Red);
+        }
+
+        foreach (var method in methods)
+        {
+            // clear these from the body.
+            method.Body.Instructions.Clear();
+            method.Body.Variables.Clear();
+            method.Body.ExceptionHandlers.Clear();
+
+            // return true;
+            var ins = Instruction.Create(OpCodes.Ldc_I4_1);
+            var ins1 = Instruction.Create(OpCodes.Ret);
+
+            // add instructions
+            method.Body.Instructions.Add(ins);
+            method.Body.Instructions.Add(ins1);
+        }
+    }
+
+    /// <summary>
+    /// <para>Finds the method called RunValidation and MoveNext.</para>
+    /// <para>Checks that we found two of these methods,</para>
+    /// <para>if this is not the case, this needs to be checked.</para>
+    /// <para>This type passed in is the only type with this method.</para>
+    /// </summary>
+    /// <param name="oldAssembly"></param>
+    /// <param name="type"></param>
+    private static void SetRunValidationCode(AssemblyDefinition oldAssembly, TypeDefinition type)
+    {
+        var method = type.Methods.First(x => x.Name == "RunValidation");
+        var method2 = type.NestedTypes[0].Methods.First(x => x.Name == "MoveNext");
+
+        if (method == null || method.Body.Instructions.Count != 25)
+        {
+            Logger.Log($"RunValidation Instructions count has changed from 25 to {method.Body.Instructions.Count}", ConsoleColor.Red);
+        }
+
+        if (method2 == null || method2.Body.Instructions.Count != 171)
+        {
+            Logger.Log($"RunValidation's MoveNext Instructions count has changed from 171 to {method2.Body.Instructions.Count}", ConsoleColor.Red);
+        }
+
+        // Clear these from the body of each method respectively
+        method.Body.Instructions.Clear();
+        method2.Body.Instructions.Clear();
+        method2.Body.Variables.Clear();
+        method2.Body.ExceptionHandlers.Clear();
+
+        var processor = method.Body.GetILProcessor();
+        var processor2 = method2.Body.GetILProcessor();
+
+        var liList = DumpyInstructionsHelper.GetRunValidationInstructions(oldAssembly, method);
+        var liList2 = DumpyInstructionsHelper.GetRunValidationInstructionsMoveNext(oldAssembly, method2);
+
+        foreach (var instruction in liList)
+        {
+            processor.Append(instruction);
+        }
+
+        foreach (var instruction in liList2)
+        {
+            processor2.Append(instruction);
+        }
+
+        var ins = Instruction.Create(OpCodes.Leave_S, method2.Body.Instructions[14]); // Create instruction to jump to index 14
+        var ins1 = Instruction.Create(OpCodes.Leave_S, method2.Body.Instructions[method2.Body.Instructions.IndexOf(method2.Body.Instructions.Last())]); // Create instruction to jump to last index
+
+        processor2.InsertAfter(method2.Body.Instructions[5], ins); // Instruction to jump from 5 to 14
+        processor2.InsertAfter(method2.Body.Instructions[14], ins1); // Instruction to jump from 14 to last index
+
+        // Create exception handler with defined indexes
+        var handler = new ExceptionHandler(ExceptionHandlerType.Catch)
+        {
+            TryStart = method2.Body.Instructions[3],
+            TryEnd = method2.Body.Instructions[7],
+            HandlerStart = method2.Body.Instructions[7],
+            HandlerEnd = method2.Body.Instructions[16],
+            CatchType = method2.Module.ImportReference(typeof(Exception)),
+        };
+
+        // Add exception handler to method body
+        method2.Body.ExceptionHandlers.Add(handler);
+    }
+
+    /// <summary>
+    /// <para>Finds the method called EnsureConsistency.</para>
+    /// <para>if this is not the case, this needs to be checked.</para>
+    /// <para>This type passed in is the only type with this method.</para>
+    /// </summary>
+    /// <param name="oldFileChecker"></param>
+    /// <param name="type"></param>
+    private static void SetEnsureConsistencyCode(AssemblyDefinition oldFileChecker, TypeDefinition type)
+    {
+        var method = type.Methods.First(x => x.Name == "EnsureConsistency");
+
+        if (method == null || method.Body.Instructions.Count != 152)
+        {
+            Logger.Log($"EnsureConsistency is null or Instructions count has changed from 152 to {method.Body.Instructions.Count}", ConsoleColor.Red);
+        }
+
+        var processor = method.Body.GetILProcessor();
+
+        // clear these from the method body
+        method.Body.Instructions.Clear();
+        method.Body.Variables.Clear();
+        method.Body.ExceptionHandlers.Clear();
+
+        var liList = DumpyInstructionsHelper.GetEnsureConsistencyInstructions(oldFileChecker, method);
+
+        foreach (var li in liList)
+        {
+            processor.Append(li);
+        }
+    }
+
+    /// <summary>
+    /// <para>Finds the method called EnsureConsistencySingle.</para>
+    /// <para>if this is not the case, this needs to be checked.</para>
+    /// <para>This type passed in is the only type with this method.</para>
+    /// </summary>
+    /// <param name="oldFileChecker"></param>
+    /// <param name="type"></param>
+    private static void SetEnsureConsistencySingleCode(AssemblyDefinition oldFileChecker, TypeDefinition type)
+    {
+        var method = type.Methods.First(x => x.Name == "EnsureConsistencySingle");
+
+        if (method == null || method.Body.Instructions.Count != 101)
+        {
+            Logger.Log($"EnsureConsistencySingle is null or Instructions count has changed from 101 to {method.Body.Instructions.Count}", ConsoleColor.Red);
+        }
+
+        // clear these from the method body
+        method.Body.Instructions.Clear();
+        method.Body.Variables.Clear();
+        method.Body.ExceptionHandlers.Clear();
+
+        var processor = method.Body.GetILProcessor();
+
+        var liList = DumpyInstructionsHelper.GetEnsureConsistencyInstructions(oldFileChecker, method);
+
+        foreach (var li in liList)
+        {
+            processor.Append(li);
+        }
+    }
+
+    private static void SetDumpyTaskCode(AssemblyDefinition oldAssembly, TypeDefinition type)
+    {
+        var method = type.Methods.First(x => x.Name == "Awake");
+
+        if (method == null || method.Body.Instructions.Count != 62)
+        {
+            Logger.Log($"MainMenu is null or instructions have changed from 62 to {method.Body.Instructions.Count}", ConsoleColor.Red);
+        }
+
+        var processor = method.Body.GetILProcessor();
+
+        var liList = DumpyInstructionsHelper.GetDumpyTaskInstructions(oldAssembly, method);
+
+        var index = method.Body.Instructions.First(x => x.OpCode == OpCodes.Ret);
+
+        foreach (var item in liList)
+        {
+            processor.InsertBefore(index, item);
+        }
+    }
+
+    /// <summary>
+    /// Checks for null or multiple types
+    /// </summary>
+    /// <param name="types">ICollection</param>
+    /// <param name="name">string</param>
+    public static void CheckNullOrMulti(List<TypeDefinition> types, string name = "")
+    {
+        if (types == null)
+        {
+            Logger.Log($"{name} was null", ConsoleColor.Red);
+        }
+
+        if (types.Count > 1)
+        {
+            Logger.Log($"{name} count was more than 1", ConsoleColor.Red);
+        }
+    }
+}

RecodeItLib/Dumper/Dumpy.cs

@@ -1,331 +0,0 @@
-using System.Collections;
-using dnlib.DotNet;
-using dnlib.DotNet.Emit;
-using ReCodeIt.Utils;
-
-namespace ReCodeItLib.Dumper;
-
-public class Dumpy
-{
-    private ModuleDefMD? _gameModule { get; set; }
-    private ModuleDefMD? _checkerModule { get; set; }
-    private string _assemblyPath { get; set; }
-    private string _fileCheckerPath { get; set; }
-    private string _path { get; set; }
-    private List<TypeDef>? _gameTypes { get; set; }
-    private List<TypeDef>? _checkerTypes { get; set; }
-
-    public Dumpy(string assemblyPath, string fileCheckerPath, string path)
-    {
-        _assemblyPath = assemblyPath;
-        _fileCheckerPath = fileCheckerPath;
-        _path = path;
-
-        if (!File.Exists(_assemblyPath))
-        {
-            Logger.Log($"File does not exist at: {_assemblyPath}", ConsoleColor.Red);
-            return;
-        }
-
-        if (!File.Exists(_fileCheckerPath))
-        {
-            Logger.Log($"File does not exist at: {_fileCheckerPath}", ConsoleColor.Red);
-            return;
-        }
-
-        _gameModule = DataProvider.LoadModule(_assemblyPath);
-        _checkerModule = DataProvider.LoadModule(_fileCheckerPath);
-        _gameTypes = _gameModule.GetTypes().ToList();
-        _checkerTypes = _checkerModule.GetTypes().ToList();
-    }
-
-    public void CreateDumper()
-    {
-        if (_gameModule == null || _gameTypes == null)
-        {
-            Logger.Log($"_gameModule or _gameTypes in Dumpy was null", ConsoleColor.Red);
-            return;
-        }
-
-        if (_checkerModule == null || _checkerTypes == null)
-        {
-            Logger.Log($"_checkerModule or _checkerTypes in Dumpy was null", ConsoleColor.Red);
-            return;
-        }
-
-        // make changes to assembly
-
-        // get required types
-        // var backRequestType = _gameTypes.Where(DumpyTypeHelper.GetBackRequestType).ToList();
-        // var validateCertType = _gameTypes.Where(DumpyTypeHelper.GetValidateCertType).ToList();
-        // var runValidationType = _gameTypes.Where(DumpyTypeHelper.GetRunValidationType).ToList();
-        // var dumpyTaskType = _gameTypes.Where(DumpyTypeHelper.GetMenuscreenType).ToList();
-        
-        // check types
-        // CheckNullOrMulti(backRequestType, "BackRequest");
-        // CheckNullOrMulti(validateCertType, "ValidateCertificate");
-        // CheckNullOrMulti(runValidationType, "RunValidation");
-        // CheckNullOrMulti(dumpyTaskType, "DumpyTask");
-        
-        // apply code changes
-        // SetBackRequestCode(backRequestType[0]);
-        // SetValidateCertCode(validateCertificateType[0]);
-        // SetRunValidationCode(runValidationType[0]);
-        // SetDumpyTaskCode(dumpyTaskType[0]);
-
-        // TODO: Write game assembly to file
-        
-        // get types
-        // var ensureConsistencyTypes = _checkerTypes.Where(DumpyTypeHelper.GetEnsureConsistencyType).ToList();
-        // check types
-        // CheckNullOrMulti(ensureConsistencyTypes, "EnsureConsistency");
-        
-        // apply code changes
-        // SetEnsureConsistencyCode(ensureConsistencyType[0]);
-        // SetEnsureConsistencySingleCode(ensureConsistencyType[0]);
-        
-        // TODO: Write fileChecker assembly to file
-    }
-
-    public void CreateDumpFolders()
-    {
-        // create dumper folders
-    }
-
-    /// <summary>
-    /// Checks for null or multiple types
-    /// </summary>
-    /// <param name="types">ICollection</param>
-    /// <param name="name">string</param>
-    private void CheckNullOrMulti(ICollection types, string name = "")
-    {
-        if (types == null)
-        {
-            Logger.Log($"{name} was null");
-        }
-
-        if (types.Count > 1)
-        {
-            Logger.Log($"{name} count was more than 1");
-        }
-    }
-
-    /// <summary>
-    /// <para>Finds the method with backRequest and bResponse as params.</para>
-    /// <para>Checks the method instructions before modification has a count of 269,</para>
-    /// <para>if this is not the case, this needs to be checked.</para>
-    /// <para>This type passed in is the only type with this method.</para>
-    /// </summary>
-    /// <param name="oldAssembly"></param>
-    /// <param name="type"></param>
-    private void SetBackRequestCode(TypeDef type)
-    {
-        // find method
-        var method = type.Methods.First(x => x.Parameters.Any(p => p.Name is "backRequest" && x.Parameters.Any(p => p.Name == "bResponse")));
-
-        if (method == null || method.Body.Instructions.Count != 269)
-        {
-            Logger.Log($"BackRequest Instructions count has changed from 269 to {method.Body.Instructions.Count}", ConsoleColor.Red);
-        }
-
-        var startOfInstructions = 252;
-        // var liList = DumpyInstructionsHelper.GetBackRequestInstructions();
-        var index = method.Body.Instructions[startOfInstructions];
-
-        // foreach (var li in liList)
-        // {
-        //     // something along these lines, this needs to be tested
-        //     method.Body.Instructions.InsertBefore(index, li);
-        // }
-
-        // create instruction
-        var ins = Instruction.Create(OpCodes.Brfalse_S, method.Body.Instructions[startOfInstructions]);
-
-        // replace instruction at 220 with this
-        method.Body.Instructions[220] = ins;
-    }
-
-    /// <summary>
-    /// <para>Finds the method called ValidateCertificate.</para>
-    /// <para>Checks that we found two of these methods,</para>
-    /// <para>if this is not the case, this needs to be checked.</para>
-    /// <para>This type passed in is the only type with this method.</para>
-    /// </summary>
-    /// <param name="oldAssembly"></param>
-    /// <param name="type"></param>
-    private void SetValidateCertCode(TypeDef type)
-    {
-        var methods = type.Methods.Where(x =>
-            x.Name == "ValidateCertificate"); // should be 2
-
-        // check make sure nothing has changed
-        var firstMethod = methods.FirstOrDefault(m => m.Parameters.Any(p => p.Name == "certificate"));
-        var secondMethod = methods.FirstOrDefault(m => m.Parameters.Any(p => p.Name == "certificateData"));
-
-        if (firstMethod?.Body.Instructions.Count != 55 || secondMethod?.Body.Instructions.Count != 14)
-        {
-            Logger.Log($"Instruction count has changed, method with 'certificate' as a param - before: 51, now: {firstMethod.Body.Instructions.Count}, " +
-                       $"method with 'certificateData' as a param - before: 14, now: {secondMethod.Body.Instructions.Count}", ConsoleColor.Red);
-        }
-
-        if (methods.Count() != 2)
-        {
-            Logger.Log($"ValidateCertificate should be found twice, count was: {methods.Count()}", ConsoleColor.Red);
-        }
-
-        foreach (var method in methods)
-        {
-            // clear these from the body.
-            method.Body.Instructions.Clear();
-            method.Body.Variables.Clear();
-            method.Body.ExceptionHandlers.Clear();
-
-            // return true;
-            var ins = Instruction.Create(OpCodes.Ldc_I4_1);
-            var ins1 = Instruction.Create(OpCodes.Ret);
-
-            // add instructions
-            method.Body.Instructions.Add(ins);
-            method.Body.Instructions.Add(ins1);
-        }
-    }
-
-    /// <summary>
-    /// <para>Finds the method called RunValidation and MoveNext.</para>
-    /// <para>Checks that we found two of these methods,</para>
-    /// <para>if this is not the case, this needs to be checked.</para>
-    /// <para>This type passed in is the only type with this method.</para>
-    /// </summary>
-    /// <param name="oldAssembly"></param>
-    /// <param name="type"></param>
-    private void SetRunValidationCode(TypeDef type)
-    {
-        var method = type.Methods.First(x => x.Name == "RunValidation");
-        var method2 = type.NestedTypes[0].Methods.First(x => x.Name == "MoveNext");
-
-        if (method == null || method.Body.Instructions.Count != 25)
-        {
-            Logger.Log($"RunValidation Instructions count has changed from 25 to {method.Body.Instructions.Count}");
-        }
-
-        if (method2 == null || method2.Body.Instructions.Count != 171)
-        {
-            Logger.Log($"RunValidation's MoveNext Instructions count has changed from 171 to {method2.Body.Instructions.Count}");
-        }
-
-        // Clear these from the body of each method respectively
-        method.Body.Instructions.Clear();
-        method2.Body.Instructions.Clear();
-        method2.Body.Variables.Clear();
-        method2.Body.ExceptionHandlers.Clear();
-
-        // var liList = DumpyInstructionsHelper.GetRunValidationInstructions(oldAssembly, method);
-        // var liList2 = DumpyInstructionsHelper.GetRunValidationInstructionsMoveNext(oldAssembly, method2);
-
-        // foreach (var instruction in liList)
-        // {
-        //     method.Body.Instructions.Append(instruction);
-        // }
-        //
-        // foreach (var instruction in liList2)
-        // {
-        //     method2.Body.Instructions.Append(instruction);
-        // }
-
-        var ins = Instruction.Create(OpCodes.Leave_S, method2.Body.Instructions[14]); // Create instruction to jump to index 14
-        var ins1 = Instruction.Create(OpCodes.Leave_S, method2.Body.Instructions[method2.Body.Instructions.IndexOf(method2.Body.Instructions.Last())]); // Create instruction to jump to last index
-
-        method2.Body.Instructions.InsertAfter(method2.Body.Instructions[5], ins); // Instruction to jump from 5 to 14
-        method2.Body.Instructions.InsertAfter(method2.Body.Instructions[14], ins1); // Instruction to jump from 14 to last index
-
-        // Create exception handler with defined indexes
-        var handler = new ExceptionHandler(ExceptionHandlerType.Catch)
-        {
-            TryStart = method2.Body.Instructions[3],
-            TryEnd = method2.Body.Instructions[7],
-            HandlerStart = method2.Body.Instructions[7],
-            HandlerEnd = method2.Body.Instructions[16],
-            // CatchType = method2.Module.ImportReference(typeof(Exception)), // needs fixing
-        };
-
-        // Add exception handler to method body
-        method2.Body.ExceptionHandlers.Add(handler);
-    }
-
-    private void SetDumpyTaskCode(TypeDef type)
-    {
-        var method = type.Methods.First(x => x.Name == "Awake");
-
-        if (method == null || method.Body.Instructions.Count != 62)
-        {
-            Logger.Log($"MainMenu is null or isnt 62 instructions, SOMETHING HAD CHANGED!", ConsoleColor.Red);
-        }
-
-        // var liList = DumpyInstructionsHelper.GetDumpyTaskInstructions(oldAssembly, method);
-
-        var index = method.Body.Instructions.First(x => x.OpCode == OpCodes.Ret);
-
-        // foreach (var item in liList)
-        // {
-        //     method.Body.Instructions.InsertBefore(index, item);
-        // }
-    }
-
-    /// <summary>
-    /// <para>Finds the method called EnsureConsistency.</para>
-    /// <para>if this is not the case, this needs to be checked.</para>
-    /// <para>This type passed in is the only type with this method.</para>
-    /// </summary>
-    /// <param name="oldFileChecker"></param>
-    /// <param name="type"></param>
-    private static void SetEnsureConsistencyCode(TypeDef type)
-    {
-        var method = type.Methods.First(x => x.Name == "EnsureConsistency");
-
-        if (method == null || method.Body.Instructions.Count != 152)
-        {
-            Logger.Log($"EnsureConsistency Instructions count has changed from 152 to {method.Body.Instructions.Count}", ConsoleColor.Red);
-        }
-
-        // clear these from the method body
-        method.Body.Instructions.Clear();
-        method.Body.Variables.Clear();
-        method.Body.ExceptionHandlers.Clear();
-
-        // var liList = DumpyInstructionsHelper.GetEnsureConsistencyInstructions(oldFileChecker, method);
-        //
-        // foreach (var li in liList)
-        // {
-        //     method.Body.Instructions.Append(li);
-        // }
-    }
-
-    /// <summary>
-    /// <para>Finds the method called EnsureConsistencySingle.</para>
-    /// <para>if this is not the case, this needs to be checked.</para>
-    /// <para>This type passed in is the only type with this method.</para>
-    /// </summary>
-    /// <param name="oldFileChecker"></param>
-    /// <param name="type"></param>
-    private static void SetEnsureConsistencySingleCode(TypeDef type)
-    {
-        var method = type.Methods.First(x => x.Name == "EnsureConsistencySingle");
-
-        if (method == null || method.Body.Instructions.Count != 101)
-        {
-            Logger.Log($"EnsureConsistencySingle Instructions count has changed from 101 to {method.Body.Instructions.Count}", ConsoleColor.Red);
-        }
-
-        // clear these from the method body
-        method.Body.Instructions.Clear();
-        method.Body.Variables.Clear();
-        method.Body.ExceptionHandlers.Clear();
-
-        // var liList = DumpyInstructionsHelper.GetEnsureConsistencyInstructions(oldFileChecker, method);
-        //
-        // foreach (var li in liList)
-        // {
-        //     method.Body.Instructions.Append(li);
-        // }
-    }
-}

RecodeItLib/Dumper/DumpyInstructionsHelper.cs

@@ -1,170 +1,172 @@
-// using System;
+using System;
-// using System.Collections.Generic;
+using System.Collections.Generic;
-// using System.Linq;
+using System.Linq;
-// using System.Threading.Tasks;
+using System.Threading.Tasks;
-// using DumpLib;
+using DumpLib;
-//
+using Mono.Cecil;
-// namespace ReCodeItLib.Dumper;
+using Mono.Cecil.Cil;
-//
+
-// public static class DumpyInstructionsHelper
+namespace ReCodeItLib.Dumper;
-// {
+
-//     /// <summary>
+public static class DumpyInstructionsHelper
-//     /// <para>Sets up local variables and returns a List of instructions to add.</para>
+{
-//     /// </summary>
+    /// <summary>
-//     /// <param name="assembly">AssemblyDefinition</param>
+    /// <para>Sets up local variables and returns a List of instructions to add.</para>
-//     /// <param name="method">MethodDefinition</param>
+    /// </summary>
-//     /// <returns>List<Instruction></returns>
+    /// <param name="assembly">AssemblyDefinition</param>
-//     public static List<Instruction> GetBackRequestInstructions(AssemblyDefinition assembly, MethodDefinition method)
+    /// <param name="method">MethodDefinition</param>
-//     {
+    /// <returns>List<Instruction></returns>
-//         return new List<Instruction>
+    public static List<Instruction> GetBackRequestInstructions(AssemblyDefinition assembly, MethodDefinition method)
-//         {
+    {
-//             Instruction.Create(OpCodes.Ldarg_1),
+        return new List<Instruction>
-//             Instruction.Create(OpCodes.Ldloc_S, method.Body.Variables[6]),
+        {
-//             Instruction.Create(OpCodes.Call, assembly.MainModule.ImportReference(typeof(DumpLib.DumpyTool).GetMethod("LogRequestResponse", new[] { typeof(object), typeof(object) })))
+            Instruction.Create(OpCodes.Ldarg_1),
-//         };
+            Instruction.Create(OpCodes.Ldloc_S, method.Body.Variables[6]),
-//     }
+            Instruction.Create(OpCodes.Call, assembly.MainModule.ImportReference(typeof(DumpLib.DumpyTool).GetMethod("LogRequestResponse", new[] { typeof(object), typeof(object) })))
-//
+        };
-//     /// <summary>
+    }
-//     /// <para>Returns a List of instructions to be added to the method.</para>
+
-//     /// <para>This is an Async method so there is two parts, this part and a RunValidation method.</para>
+    /// <summary>
-//     /// </summary>
+    /// <para>Returns a List of instructions to be added to the method.</para>
-//     /// <param name="assembly">AssemblyDefinition</param>
+    /// <para>This is an Async method so there is two parts, this part and a RunValidation method.</para>
-//     /// <param name="method">MethodDefinition</param>
+    /// </summary>
-//     /// <returns>List<Instruction></returns>
+    /// <param name="assembly">AssemblyDefinition</param>
-//     public static List<Instruction> GetRunValidationInstructionsMoveNext(AssemblyDefinition assembly, MethodDefinition method)
+    /// <param name="method">MethodDefinition</param>
-//     {
+    /// <returns>List<Instruction></returns>
-//         // Add our own local variables
+    public static List<Instruction> GetRunValidationInstructionsMoveNext(AssemblyDefinition assembly, MethodDefinition method)
-//
+    {
-//         // var1 index0 class1159Type
+        // Add our own local variables
-//         var sptClassType = assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType);
+
-//         var sptClass = new VariableDefinition(sptClassType);
+        // var1 index0 class1159Type
-//         method.Body.Variables.Add(sptClass);
+        var sptClassType = assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType);
-//
+        var sptClass = new VariableDefinition(sptClassType);
-//         // var2 index1 ExceptionType
+        method.Body.Variables.Add(sptClass);
-//         var sptExceptionType = method.Module.ImportReference(typeof(Exception));
+
-//         var sptException = new VariableDefinition(sptExceptionType);
+        // var2 index1 ExceptionType
-//         method.Body.Variables.Add(sptException);
+        var sptExceptionType = method.Module.ImportReference(typeof(Exception));
-//
+        var sptException = new VariableDefinition(sptExceptionType);
-//         return new List<Instruction>
+        method.Body.Variables.Add(sptException);
-//         {
+
-//             // most of this is to keep the Async happy
+        return new List<Instruction>
-//
+        {
-//             Instruction.Create(OpCodes.Ldarg_0),
+            // most of this is to keep the Async happy
-//             Instruction.Create(OpCodes.Ldfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[2]),
+
-//             Instruction.Create(OpCodes.Stloc_0),
+            Instruction.Create(OpCodes.Ldarg_0),
-//
+            Instruction.Create(OpCodes.Ldfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[2]),
-//             // this.Succeed = true;
+            Instruction.Create(OpCodes.Stloc_0),
-//             Instruction.Create(OpCodes.Ldloc_0),
+
-//             Instruction.Create(OpCodes.Ldc_I4_1),
+            // this.Succeed = true;
-//             Instruction.Create(OpCodes.Call, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).Methods.First(x => x.Name == "set_Succeed")),
+            Instruction.Create(OpCodes.Ldloc_0),
-//
+            Instruction.Create(OpCodes.Ldc_I4_1),
-//             Instruction.Create(OpCodes.Stloc_1),
+            Instruction.Create(OpCodes.Call, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).Methods.First(x => x.Name == "set_Succeed")),
-//             Instruction.Create(OpCodes.Ldarg_0),
+
-//             Instruction.Create(OpCodes.Ldc_I4_S, (sbyte)-2),
+            Instruction.Create(OpCodes.Stloc_1),
-//             Instruction.Create(OpCodes.Stfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[0]),
+            Instruction.Create(OpCodes.Ldarg_0),
-//             Instruction.Create(OpCodes.Ldarg_0),
+            Instruction.Create(OpCodes.Ldc_I4_S, (sbyte)-2),
-//             Instruction.Create(OpCodes.Ldflda, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]),
+            Instruction.Create(OpCodes.Stfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[0]),
-//             Instruction.Create(OpCodes.Ldloc_1),
+            Instruction.Create(OpCodes.Ldarg_0),
-//             Instruction.Create(OpCodes.Call,
+            Instruction.Create(OpCodes.Ldflda, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]),
-//                 method.Module.ImportReference(assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.Resolve().Methods.First(x => x.Name == "SetException"))),
+            Instruction.Create(OpCodes.Ldloc_1),
-//
+            Instruction.Create(OpCodes.Call,
-//             Instruction.Create(OpCodes.Ldarg_0),
+                method.Module.ImportReference(assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.Resolve().Methods.First(x => x.Name == "SetException"))),
-//             Instruction.Create(OpCodes.Ldc_I4_S, (sbyte)-2),
+
-//             Instruction.Create(OpCodes.Stfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[0]),
+            Instruction.Create(OpCodes.Ldarg_0),
-//
+            Instruction.Create(OpCodes.Ldc_I4_S, (sbyte)-2),
-//             Instruction.Create(OpCodes.Ldarg_0),
+            Instruction.Create(OpCodes.Stfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[0]),
-//             Instruction.Create(OpCodes.Ldflda, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]),
+
-//             Instruction.Create(OpCodes.Call, method.Module.ImportReference(assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.Resolve().Methods.First(x => x.Name == "SetResult"))),
+            Instruction.Create(OpCodes.Ldarg_0),
-//
+            Instruction.Create(OpCodes.Ldflda, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]),
-//             Instruction.Create(OpCodes.Ret),
+            Instruction.Create(OpCodes.Call, method.Module.ImportReference(assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.Resolve().Methods.First(x => x.Name == "SetResult"))),
-//         };
+
-//     }
+            Instruction.Create(OpCodes.Ret),
-//
+        };
-//     /// <summary>
+    }
-//     /// <para>Returns a List of instructions to be added to the method.</para>
+
-//     /// <para>This is an Async method so there is two parts, this part and a RunValidation method.</para>
+    /// <summary>
-//     /// </summary>
+    /// <para>Returns a List of instructions to be added to the method.</para>
-//     /// <param name="assembly">AssemblyDefinition</param>
+    /// <para>This is an Async method so there is two parts, this part and a RunValidation method.</para>
-//     /// <param name="method">MethodDefinition</param>
+    /// </summary>
-//     /// <returns>List<Instruction></returns>
+    /// <param name="assembly">AssemblyDefinition</param>
-//     public static List<Instruction> GetEnsureConsistencyInstructions(AssemblyDefinition oldFileChecker, MethodDefinition method)
+    /// <param name="method">MethodDefinition</param>
-//     {
+    /// <returns>List<Instruction></returns>
-//         // init local vars
+    public static List<Instruction> GetEnsureConsistencyInstructions(AssemblyDefinition oldFileChecker, MethodDefinition method)
-//         // var1 index0 TimeSpan type
+    {
-//         var sptTimeSpanType = method.Module.ImportReference(typeof(TimeSpan));
+        // init local vars
-//         var sptClass = new VariableDefinition(sptTimeSpanType);
+        // var1 index0 TimeSpan type
-//         method.Body.Variables.Add(sptClass);
+        var sptTimeSpanType = method.Module.ImportReference(typeof(TimeSpan));
-//
+        var sptClass = new VariableDefinition(sptTimeSpanType);
-//         // Create genericInstance of a method
+        method.Body.Variables.Add(sptClass);
-//         var type = oldFileChecker.MainModule.GetTypes().First(DumpyTypeHelper.GetEnsureConsistencyType).NestedTypes[0].Interfaces[0].InterfaceType;
+
-//         var typeMethod = method.Module.ImportReference(typeof(Task).GetMethod("FromResult"));
+        // Create genericInstance of a method
-//         var instanceType = new GenericInstanceMethod(typeMethod);
+        var type = oldFileChecker.MainModule.GetTypes().First(DumpyTypeHelper.GetEnsureConsistencyType).NestedTypes[0].Interfaces[0].InterfaceType;
-//         instanceType.GenericArguments.Add(type);
+        var typeMethod = method.Module.ImportReference(typeof(Task).GetMethod("FromResult"));
-//
+        var instanceType = new GenericInstanceMethod(typeMethod);
-//         return new List<Instruction>
+        instanceType.GenericArguments.Add(type);
-//         {
+
-//             // return Task.FromResult<ICheckResult>(ConsistencyController.CheckResult.Succeed(default(TimeSpan)));
+        return new List<Instruction>
-//             Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]),
+        {
-//             Instruction.Create(OpCodes.Initobj, method.Module.ImportReference(typeof(TimeSpan))),
+            // return Task.FromResult<ICheckResult>(ConsistencyController.CheckResult.Succeed(default(TimeSpan)));
-//             Instruction.Create(OpCodes.Ldloc_0),
+            Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]),
-//             Instruction.Create(OpCodes.Call, oldFileChecker.MainModule.GetTypes().First(DumpyTypeHelper.GetEnsureConsistencyType).NestedTypes[0].Methods.First(x => x.Name == "Succeed")),
+            Instruction.Create(OpCodes.Initobj, method.Module.ImportReference(typeof(TimeSpan))),
-//             Instruction.Create(OpCodes.Call, instanceType),
+            Instruction.Create(OpCodes.Ldloc_0),
-//             Instruction.Create(OpCodes.Ret)
+            Instruction.Create(OpCodes.Call, oldFileChecker.MainModule.GetTypes().First(DumpyTypeHelper.GetEnsureConsistencyType).NestedTypes[0].Methods.First(x => x.Name == "Succeed")),
-//         };
+            Instruction.Create(OpCodes.Call, instanceType),
-//     }
+            Instruction.Create(OpCodes.Ret)
-//
+        };
-//     /// <summary>
+    }
-//     /// <para>Returns a List of instructions to be added to the method.</para>
+
-//     /// <para>This is an Async method so there is two parts, this part and a MoveNext method.</para>
+    /// <summary>
-//     /// </summary>
+    /// <para>Returns a List of instructions to be added to the method.</para>
-//     /// <param name="assembly">AssemblyDefinition</param>
+    /// <para>This is an Async method so there is two parts, this part and a MoveNext method.</para>
-//     /// <param name="method">MethodDefinition</param>
+    /// </summary>
-//     /// <returns>List<Instruction></returns>
+    /// <param name="assembly">AssemblyDefinition</param>
-//     public static List<Instruction> GetRunValidationInstructions(AssemblyDefinition assembly, MethodDefinition method)
+    /// <param name="method">MethodDefinition</param>
-//     {
+    /// <returns>List<Instruction></returns>
-//         // Create genericInstance of a method
+    public static List<Instruction> GetRunValidationInstructions(AssemblyDefinition assembly, MethodDefinition method)
-//         var type = assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0];
+    {
-//         var typeMethod = method.Module.ImportReference(assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.Resolve().Methods.First(x => x.Name == "Start"));
+        // Create genericInstance of a method
-//         var instanceMethod = new GenericInstanceMethod(typeMethod);
+        var type = assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0];
-//         instanceMethod.GenericArguments.Add(type);
+        var typeMethod = method.Module.ImportReference(assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.Resolve().Methods.First(x => x.Name == "Start"));
-//
+        var instanceMethod = new GenericInstanceMethod(typeMethod);
-//         return new List<Instruction>
+        instanceMethod.GenericArguments.Add(type);
-//         {
+
-//             // <RunValidation>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
+        return new List<Instruction>
-//             Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]),
+        {
-//             Instruction.Create(OpCodes.Call, method.Module.ImportReference(assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.Resolve().Methods.First(x => x.Name == "Create"))),
+            // <RunValidation>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
-//             Instruction.Create(OpCodes.Stfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]),
+            Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]),
-//
+            Instruction.Create(OpCodes.Call, method.Module.ImportReference(assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.Resolve().Methods.First(x => x.Name == "Create"))),
-//             // <RunValidation>d__.<>4__this = this;
+            Instruction.Create(OpCodes.Stfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]),
-//             Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]),
+
-//             Instruction.Create(OpCodes.Ldarg_0),
+            // <RunValidation>d__.<>4__this = this;
-//             Instruction.Create(OpCodes.Stfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[2]),
+            Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]),
-//
+            Instruction.Create(OpCodes.Ldarg_0),
-//             // <RunValidation>d__.<>1__state = -1;
+            Instruction.Create(OpCodes.Stfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[2]),
-//             Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]),
+
-//             Instruction.Create(OpCodes.Ldc_I4_M1),
+            // <RunValidation>d__.<>1__state = -1;
-//             Instruction.Create(OpCodes.Stfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[0]),
+            Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]),
-//
+            Instruction.Create(OpCodes.Ldc_I4_M1),
-//             // <RunValidation>d__.<>t__builder.Start<Class1159.<RunValidation>d__0>(ref <RunValidation>d__);
+            Instruction.Create(OpCodes.Stfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[0]),
-//             Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]),
+
-//             Instruction.Create(OpCodes.Ldflda, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]),
+            // <RunValidation>d__.<>t__builder.Start<Class1159.<RunValidation>d__0>(ref <RunValidation>d__);
-//             Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]),
+            Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]),
-//             Instruction.Create(OpCodes.Call, instanceMethod),
+            Instruction.Create(OpCodes.Ldflda, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]),
-//
+            Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]),
-//             // return <RunValidation>d__.<>t__builder.Task;
+            Instruction.Create(OpCodes.Call, instanceMethod),
-//             Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]),
+
-//             Instruction.Create(OpCodes.Ldflda, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]),
+            // return <RunValidation>d__.<>t__builder.Task;
-//             Instruction.Create(OpCodes.Call, method.Module.ImportReference(assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.Resolve().Methods.First(x => x.Name == "get_Task"))),
+            Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]),
-//             Instruction.Create(OpCodes.Ret),
+            Instruction.Create(OpCodes.Ldflda, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]),
-//         };
+            Instruction.Create(OpCodes.Call, method.Module.ImportReference(assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.Resolve().Methods.First(x => x.Name == "get_Task"))),
-//     }
+            Instruction.Create(OpCodes.Ret),
-//
+        };
-//     public static List<Instruction> GetDumpyTaskInstructions(AssemblyDefinition oldAssembly, MethodDefinition method)
+    }
-//     {
+
-//         return new List<Instruction>
+    public static List<Instruction> GetDumpyTaskInstructions(AssemblyDefinition oldAssembly, MethodDefinition method)
-//         {
+    {
-//             Instruction.Create(OpCodes.Call, oldAssembly.MainModule.ImportReference(typeof(DumpyTool).GetMethod("StartDumpyTask"))),
+        return new List<Instruction>
-//             Instruction.Create(OpCodes.Pop)
+        {
-//         };
+            Instruction.Create(OpCodes.Call, oldAssembly.MainModule.ImportReference(typeof(DumpyTool).GetMethod("StartDumpyTask"))),
-//     }
+            Instruction.Create(OpCodes.Pop)
-// }
+        };
+    }
+}

RecodeItLib/Dumper/DumpyTypeHelper.cs

@@ -1,54 +1,54 @@
-// using System.Linq;
+using System.Linq;
-// using Mono.Cecil;
+using Mono.Cecil;
-//
+
-// namespace ReCodeItLib.Dumper;
+namespace ReCodeItLib.Dumper;
-//
+
-// public static class DumpyTypeHelper
+public static class DumpyTypeHelper
-// {
+{
-//     /// <summary>
+    /// <summary>
-//     /// <para>Gets the type that has a method called SendAndHandleRetries.</para>
+    /// <para>Gets the type that has a method called SendAndHandleRetries.</para>
-//     /// <para>This type is the only one with method.</para>
+    /// <para>This type is the only one with method.</para>
-//     /// </summary>
+    /// </summary>
-//     /// <param name="type">TypeDefinition</param>
+    /// <param name="type">TypeDefinition</param>
-//     /// <returns>boolean</returns>
+    /// <returns>boolean</returns>
-//     public static bool GetBackRequestType(TypeDefinition type)
+    public static bool GetBackRequestType(TypeDefinition type)
-//     {
+    {
-//         return type.Methods.Any(m => m.Name == "SendAndHandleRetries");
+        return type.Methods.Any(m => m.Name == "SendAndHandleRetries");
-//     }
+    }
-//
+
-//     /// <summary>
+    /// <summary>
-//     /// <para>Gets the type that has a method called ValidateCertificate as the name.</para>
+    /// <para>Gets the type that has a method called ValidateCertificate as the name.</para>
-//     /// </summary>
+    /// </summary>
-//     /// <param name="type">TypeDefinition</param>
+    /// <param name="type">TypeDefinition</param>
-//     /// <returns>boolean</returns>
+    /// <returns>boolean</returns>
-//     public static bool GetValidateCertificateType(TypeDefinition type)
+    public static bool GetValidateCertificateType(TypeDefinition type)
-//     {
+    {
-//         return type.Methods.Any(m => m.Name == "ValidateCertificate");
+        return type.Methods.Any(m => m.Name == "ValidateCertificate");
-//     }
+    }
-//
+
-//     /// <summary>
+    /// <summary>
-//     /// <para>Gets the type that has a method called RunValidation as the name.</para>
+    /// <para>Gets the type that has a method called RunValidation as the name.</para>
-//     /// </summary>
+    /// </summary>
-//     /// <param name="type">TypeDefinition</param>
+    /// <param name="type">TypeDefinition</param>
-//     /// <returns>boolean</returns>
+    /// <returns>boolean</returns>
-//     public static bool GetRunValidationType(TypeDefinition type)
+    public static bool GetRunValidationType(TypeDefinition type)
-//     {
+    {
-//         return type.Methods.Any(m => m.Name == "RunValidation");
+        return type.Methods.Any(m => m.Name == "RunValidation");
-//     }
+    }
-//
+
-//     /// <summary>
+    /// <summary>
-//     /// <para>Gets the type that has ConsistencyController as the name.</para>
+    /// <para>Gets the type that has ConsistencyController as the name.</para>
-//     /// <para>FilesChecker.dll is not obfuscated.</para>
+    /// <para>FilesChecker.dll is not obfuscated.</para>
-//     /// </summary>
+    /// </summary>
-//     /// <param name="type">TypeDefinition</param>
+    /// <param name="type">TypeDefinition</param>
-//     /// <returns>boolean</returns>
+    /// <returns>boolean</returns>
-//     public static bool GetEnsureConsistencyType(TypeDefinition type)
+    public static bool GetEnsureConsistencyType(TypeDefinition type)
-//     {
+    {
-//         return type.Name == "ConsistencyController";
+        return type.Name == "ConsistencyController";
-//     }
+    }
-//
+
-//     public static bool GetMenuScreenType(TypeDefinition type)
+    public static bool GetMenuScreenType(TypeDefinition type)
-//     {
+    {
-//         return type.Name == "MenuScreen";
+        return type.Name == "MenuScreen";
-//     }
+    }
-// }
+}

RecodeItLib/ReCodeItLib.csproj

@@ -183,5 +183,11 @@
     <Reference Include="DumpLib">
       <HintPath>Assets\DumpLib.dll</HintPath>
     </Reference>
+    <Reference Include="Mono.Cecil">
+      <HintPath>..\Assets\MonoCecil\Mono.Cecil.dll</HintPath>
+    </Reference>
+    <Reference Include="Mono.Cecil.Rocks">
+      <HintPath>..\Assets\MonoCecil\Mono.Cecil.Rocks.dll</HintPath>
+    </Reference>
   </ItemGroup>
 </Project>