source: binary-improvements/NamePatcher/NamePatcher.cs@ 84

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Mono.Cecil;
using System.Reflection;

namespace NamePatcher
{
        class NamePatcher
        {
                static void DrawUsage ()
                {
                        Console.WriteLine ("Usage :");
                        Console.WriteLine ("NamePatcher [input file]    Patches an Assembly and creates a backup of the original file.");
                }

                static bool TryArgs (string[] args)
                {
                        return args.Length == 1 && (File.Exists (args [0]));
                }

                static bool makeBackup (string input)
                {
                        string backupFile_base = input + ".bck";
                        string backupFile = backupFile_base;
                        int backupIndex = 0;
                        while (File.Exists(backupFile)) {
                                backupFile = backupFile_base + "." + (++backupIndex);
                                if (backupIndex > 10) {
                                        return false;
                                }
                        }
                        try {
                                File.Copy (input, backupFile);
                        } catch (Exception e) {
                                Console.WriteLine ("Unable to create backup file : ");
                                Console.WriteLine (e.ToString ());
                                return false;
                        }
                        return true;
                }

                static DefaultAssemblyResolver getAssemblyResolver (string path)
                {
                        DefaultAssemblyResolver resolver = null;
                        int lastSlash = path.LastIndexOf ("\\");
                        if (lastSlash == -1)
                                lastSlash = path.LastIndexOf ("/");
                        if (lastSlash != -1) {
                                string inputPath = path.Substring (0, lastSlash);
                                resolver = new DefaultAssemblyResolver ();
                                resolver.AddSearchDirectory (inputPath);
                        }
                        return resolver;
                }

                static void applyManualPatches (ModuleDefinition mainModule)
                {
                        foreach (FieldDefinition fd in mainModule.GetType ("AdminTools").Fields) {
                                TypeReference fdType = fd.FieldType;
                                if (fdType.FullName.Contains ("List") && fdType.FullName.Contains ("AdminToolsCommandPermissions")) {
                                        Console.WriteLine ("Renaming and making public admin tools field -> commandPermissions");
                                        fd.Attributes = fd.Attributes & (~Mono.Cecil.FieldAttributes.Private) | Mono.Cecil.FieldAttributes.Public;
                                        NameNormalizer.setName (fd, "commandPermissions");
                                }
                        }

                        foreach (FieldDefinition fd in mainModule.GetType ("World").Fields) {
                                TypeReference fdType = fd.FieldType;
                                if (fdType.FullName.Equals ("System.UInt64")) {
                                        Console.WriteLine ("Renaming world field -> gameTime");
                                        NameNormalizer.setName (fd, "gameTime");
                                }
                        }

                        foreach (FieldDefinition fd in mainModule.GetType ("GameManager").Fields) {
                                TypeReference fdType = fd.FieldType;
                                if (fdType.FullName.Equals ("ConnectionManager")) {
                                        Console.WriteLine ("Renaming and making public GameMananger field -> connectionManager");
                                        fd.Attributes = fd.Attributes & (~Mono.Cecil.FieldAttributes.Private) | Mono.Cecil.FieldAttributes.Public;
                                        NameNormalizer.setName (fd, "connectionManager");
                                }
                        }

                        foreach (FieldDefinition fd in mainModule.GetType ("ConnectionManager").Fields) {
                                TypeReference fdType = fd.FieldType;
                                if (fdType.FullName.Contains ("Dictionary") && fdType.FullName.Contains ("ClientInfo")) {
                                        Console.WriteLine ("Renaming and making public ConnectionManager field -> connectedClients");
                                        fd.Attributes = fd.Attributes & (~Mono.Cecil.FieldAttributes.Private) | Mono.Cecil.FieldAttributes.Public;
                                        NameNormalizer.setName (fd, "connectedClients");
                                }
                                if (fdType.FullName.Contains ("Dictionary") && fdType.FullName.Contains ("System.Int32,System.Int32")) {
                                        Console.WriteLine ("Renaming and making public ConnectionManager field -> mapClientToEntity");
                                        fd.Attributes = fd.Attributes & (~Mono.Cecil.FieldAttributes.Private) | Mono.Cecil.FieldAttributes.Public;
                                        NameNormalizer.setName (fd, "mapClientToEntity");
                                }
                        }

                        string consoleTypeName = string.Empty;
                        TypeDefinition typeTelnetServer = mainModule.GetType ("NetTelnetServer");
                        foreach (FieldDefinition fd in typeTelnetServer.Fields) {
                                if (NameNormalizer.makeValidName (fd.FieldType.Name) != null) {
                                        Console.WriteLine ("Renaming console class -> ConsoleSdtd");
                                        consoleTypeName = fd.FieldType.Name;
                                        NameNormalizer.setName (fd.FieldType.Resolve (), "ConsoleSdtd");
                                        NameNormalizer.setName (fd, "console");
                                }
                        }

                        if (consoleTypeName.Length > 0) {
                                TypeDefinition typeConsole = mainModule.GetType (consoleTypeName);
                                string consoleCommandTypeName = string.Empty;
                                foreach (MethodDefinition md in typeConsole.Methods) {
                                        if (!md.IsConstructor) {
                                                if (md.Parameters.Count == 3 && md.Parameters [0].ParameterType.Name.Equals ("NetworkPlayer")) {
                                                        Console.WriteLine ("Renaming console method -> ExecuteCmdFromClient");
                                                        NameNormalizer.setName (md, "ExecuteCmdFromClient");
                                                }
                                        }
                                }
                                foreach (FieldDefinition fd in typeConsole.Fields) {
                                        TypeReference fdType = fd.FieldType;
                                        if (fdType.FullName.Contains ("Generic.List")) {
                                                if (fdType.IsGenericInstance) {
                                                        GenericInstanceType genType = (GenericInstanceType)fdType;
                                                        TypeReference genRef = genType.GenericArguments [0];
                                                        if (genRef.Name.Length < 2) {
                                                                Console.WriteLine ("Renaming console command class -> ConsoleCommand");
                                                                NameNormalizer.setName (genRef.Resolve (), "ConsoleCommand");
                                                                NameNormalizer.setName (fd, "commands");
                                                                consoleCommandTypeName = genRef.Name;
                                                        }
                                                }
                                        }
                                        if (fdType.FullName.Equals ("GameManager")) {
                                                Console.WriteLine ("Renaming and making public console field -> gameManager");
                                                fd.Attributes = fd.Attributes & (~Mono.Cecil.FieldAttributes.Private) | Mono.Cecil.FieldAttributes.Public;
                                                NameNormalizer.setName (fd, "gameManager");
                                        }
                                }

                                if (consoleCommandTypeName.Length > 0) {
                                        foreach (MethodDefinition md in typeConsole.Methods) {
                                                if (md.Parameters.Count == 1 && md.Parameters [0].ParameterType.Name.Equals (consoleCommandTypeName)) {
                                                        Console.WriteLine ("Renaming console method -> AddCommand");
                                                        NameNormalizer.setName (md, "AddCommand");
                                                }
                                        }

                                        TypeDefinition typeConsoleCommand = mainModule.GetType (consoleCommandTypeName);
                                        foreach (MethodDefinition md in typeConsoleCommand.Methods) {
                                                if (!md.IsConstructor) {
                                                        if (md.Parameters.Count == 1 && md.Parameters [0].ParameterType.Name.Equals (consoleTypeName)) {
                                                                Console.WriteLine ("Renaming console command method -> Help");
                                                                NameNormalizer.setName (md, "Help");
                                                        }
                                                        if (md.Parameters.Count == 0 && md.ReturnType.Name.Equals ("Int32")) {
                                                                Console.WriteLine ("Renaming console command method -> Timeout");
                                                                NameNormalizer.setName (md, "Timeout");
                                                        }
                                                        if (md.Parameters.Count == 0 && md.ReturnType.Name.Equals ("String[]")) {
                                                                Console.WriteLine ("Renaming console command method -> Names");
                                                                NameNormalizer.setName (md, "Names");
                                                        }
                                                        if (md.Parameters.Count == 0 && md.ReturnType.Name.Equals ("String")) {
                                                                Console.WriteLine ("Renaming console command method -> Description");
                                                                NameNormalizer.setName (md, "Description");
                                                        }
                                                        if (md.Parameters.Count == 1 && md.Parameters [0].ParameterType.IsArray) {
                                                                Console.WriteLine ("Renaming console command method -> Run");
                                                                NameNormalizer.setName (md, "Run");
                                                        }
                                                }
                                        }
                                }
                        }
                }

                static void Main (string[] args)
                {
                        Console.WriteLine ("NamePatcher for 7dtd's Assembly-CSharp.dll [by DerPopo, modified by Alloc] for Dedi build 320404");
                        if (!TryArgs (args)) {
                                DrawUsage ();
                                return;
                        }
                        string dllPath = args [0];

                        if (!makeBackup (dllPath)) {
                                Console.WriteLine ("Could not create a backup file (maybe too many old backups?)");
                                return;
                        }


                        AssemblyDefinition input;
                        try {
                                input = AssemblyDefinition.ReadAssembly (dllPath, new ReaderParameters { AssemblyResolver = getAssemblyResolver(dllPath), });
                        } catch (Exception e) {
                                Console.WriteLine ("Unable to load the input file : ");
                                Console.WriteLine (e.ToString ());
                                return;
                        }
                        Console.WriteLine ();
                        Console.WriteLine ("Patching assembly " + dllPath + " (" + input.Modules.Count + " module[s]) ...");



                        applyManualPatches (input.MainModule);


                        try {
                                foreach (ModuleDefinition mdef in input.Modules) {
                                        Console.WriteLine ("Patching module " + mdef.Name + " (" + mdef.Types.Count + " type[s]) ...");
                                        foreach (TypeDefinition tdef in mdef.Types) {
                                                NameNormalizer.CheckNames (tdef);
                                        }
                                }
                        } catch (Exception e) {
                                Console.WriteLine ();
                                Console.WriteLine ("Unable to patch the assembly : ");
                                Console.WriteLine (e.ToString ());
                                return;
                        }
                        Console.WriteLine ("Finalizing patches...");

                        try {
                                NameNormalizer.FinalizeNormalizing ();
                        } catch (Exception e) {
                                Console.WriteLine ();
                                Console.WriteLine ("Unable to finalize patching : ");
                                Console.WriteLine (e.ToString ());
                                return;
                        }
                        NameNormalizer.clnamestomod.Clear ();
                        NameNormalizer.vclasses.Clear ();
                        Console.WriteLine ("Saving the patched assembly ...");

                        try {
                                input.Write (dllPath);
                        } catch (Exception e) {
                                Console.WriteLine ();
                                Console.WriteLine ("Unable to save the assembly : ");
                                Console.WriteLine (e.ToString ());
                                return;
                        }

                        Console.WriteLine ();
                        Console.WriteLine ("Success.");
                }
        }
}