diff --git a/1.5/Assemblies/0Harmony.dll b/1.5/Assemblies/0Harmony.dll new file mode 100644 index 0000000..ad4327b Binary files /dev/null and b/1.5/Assemblies/0Harmony.dll differ diff --git a/1.5/Assemblies/0Harmony.pdb b/1.5/Assemblies/0Harmony.pdb new file mode 100644 index 0000000..93aa1cc Binary files /dev/null and b/1.5/Assemblies/0Harmony.pdb differ diff --git a/1.5/Assemblies/0Harmony.xml b/1.5/Assemblies/0Harmony.xml new file mode 100644 index 0000000..b4b4897 --- /dev/null +++ b/1.5/Assemblies/0Harmony.xml @@ -0,0 +1,3745 @@ + + + + 0Harmony + + + + A factory to create delegate types + + + Default constructor + + + Creates a delegate type for a method + The method + The new delegate type + + + A getter delegate type + Type that getter gets field/property value from + Type of the value that getter gets + The instance get getter uses + An delegate + + + A setter delegate type + Type that setter sets field/property value for + Type of the value that setter sets + The instance the setter uses + The value the setter uses + An delegate + + + A constructor delegate type + Type that constructor creates + An delegate + + + A helper class for fast access to getters and setters + + + Creates an instantiation delegate + Type that constructor creates + The new instantiation delegate + + + Creates an getter delegate for a property + Type that getter reads property from + Type of the property that gets accessed + The property + The new getter delegate + + + Creates an getter delegate for a field + Type that getter reads field from + Type of the field that gets accessed + The field + The new getter delegate + + + Creates an getter delegate for a field (with a list of possible field names) + Type that getter reads field/property from + Type of the field/property that gets accessed + A list of possible field names + The new getter delegate + + + Creates an setter delegate + Type that setter assigns property value to + Type of the property that gets assigned + The property + The new setter delegate + + + Creates an setter delegate for a field + Type that setter assigns field value to + Type of the field that gets assigned + The field + The new getter delegate + + + A delegate to invoke a method + The instance + The method parameters + The method result + + + A helper class to invoke method with delegates + + + Creates a fast invocation handler from a method + The method to invoke + Controls if boxed value object is accessed/updated directly + The + + + The directBoxValueAccess option controls how value types passed by reference (e.g. ref int, out my_struct) are handled in the arguments array + passed to the fast invocation handler. + Since the arguments array is an object array, any value types contained within it are actually references to a boxed value object. + Like any other object, there can be other references to such boxed value objects, other than the reference within the arguments array. + For example, + + var val = 5; + var box = (object)val; + var arr = new object[] { box }; + handler(arr); // for a method with parameter signature: ref/out/in int + + + If directBoxValueAccess is true, the boxed value object is accessed (and potentially updated) directly when the handler is called, + such that all references to the boxed object reflect the potentially updated value. + In the above example, if the method associated with the handler updates the passed (boxed) value to 10, both box and arr[0] + now reflect the value 10. Note that the original val is not updated, since boxing always copies the value into the new boxed value object. + + + If directBoxValueAccess is false (default), the boxed value object in the arguments array is replaced with a "reboxed" value object, + such that potential updates to the value are reflected only in the arguments array. + In the above example, if the method associated with the handler updates the passed (boxed) value to 10, only arr[0] now reflects the value 10. + + + + + Delegate type for "ref return" injections + Return type of the original method, without ref modifier + + + special parameter names that can be used in prefix and postfix methods + + + Patch function helpers + + + Sorts patch methods by their priority rules + The original method + Patches to sort + Use debug mode + The sorted patch methods + + + Creates new replacement method with the latest patches and detours the original method + The original method + Information describing the patches + The newly created replacement method + + + Creates a patch sorter + Array of patches that will be sorted + Use debugging + + + Sorts internal PatchSortingWrapper collection and caches the results. + After first run the result is provided from the cache. + The original method + The sorted patch methods + + + Checks if the sorter was created with the same patch list and as a result can be reused to + get the sorted order of the patches. + List of patches to check against + true if equal + + + Removes one unresolved dependency from the least important patch. + + + Outputs all unblocked patches from the waiting list to results list + + + Adds patch to both results list and handled patches set + Patch to add + + + Wrapper used over the Patch object to allow faster dependency access and + dependency removal in case of cyclic dependencies + + + Create patch wrapper object used for sorting + Patch to wrap + + + Determines how patches sort + The other patch + integer to define sort order (-1, 0, 1) + + + Determines whether patches are equal + The other patch + true if equal + + + Hash function + A hash code + + + Bidirectionally registers Patches as after dependencies + List of dependencies to register + + + Bidirectionally registers Patches as before dependencies + List of dependencies to register + + + Bidirectionally removes Patch from after dependencies + Patch to remove + + + Bidirectionally removes Patch from before dependencies + Patch to remove + + + Specifies the type of method + + + This is a normal method + + + This is a getter + + + This is a setter + + + This is a constructor + + + This is a static constructor + + + This targets the MoveNext method of the enumerator result, that actually contains the method's implementation + + + This targets the MoveNext method of the async state machine, that actually contains the method's implementation + + + Specifies the type of argument + + + This is a normal argument + + + This is a reference argument (ref) + + + This is an out argument (out) + + + This is a pointer argument (&) + + + Specifies the type of patch + + + Any patch + + + A prefix patch + + + A postfix patch + + + A transpiler + + + A finalizer + + + A reverse patch + + + Specifies the type of reverse patch + + + Use the unmodified original method (directly from IL) + + + Use the original as it is right now including previous patches but excluding future ones + + + Specifies the type of method call dispatching mechanics + + + Call the method using dynamic dispatching if method is virtual (including overriden) + + + This is the built-in form of late binding (a.k.a. dynamic binding) and is the default dispatching mechanic in C#. + This directly corresponds with the instruction. + + + For virtual (including overriden) methods, the instance type's most-derived/overriden implementation of the method is called. + For non-virtual (including static) methods, same behavior as : the exact specified method implementation is called. + + + Note: This is not a fully dynamic dispatch, since non-virtual (including static) methods are still called non-virtually. + A fully dynamic dispatch in C# involves using + the dynamic type + (actually a fully dynamic binding, since even the name and overload resolution happens at runtime), which does not support. + + + + + Call the method using static dispatching, regardless of whether method is virtual (including overriden) or non-virtual (including static) + + + a.k.a. non-virtual dispatching, early binding, or static binding. + This directly corresponds with the instruction. + + + For both virtual (including overriden) and non-virtual (including static) methods, the exact specified method implementation is called, without virtual/override mechanics. + + + + + The base class for all Harmony annotations (not meant to be used directly) + + + The common information for all attributes + + + Annotation to define a category for use with PatchCategory + + + Annotation specifying the category + Name of patch category + + + Annotation to define your Harmony patch methods + + + An empty annotation can be used together with TargetMethod(s) + + + An annotation that specifies a class to patch + The declaring class/type + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The argument types of the method or constructor to patch + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The name of the method, property or constructor to patch + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The name of the method, property or constructor to patch + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The name of the method, property or constructor to patch + An array of argument types to target overloads + Array of + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The + An array of argument types to target overloads + Array of + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The name of the method, property or constructor to patch + The + + + An annotation that specifies a method, property or constructor to patch + The name of the method, property or constructor to patch + + + An annotation that specifies a method, property or constructor to patch + The name of the method, property or constructor to patch + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + The name of the method, property or constructor to patch + An array of argument types to target overloads + An array of + + + An annotation that specifies a method, property or constructor to patch + The name of the method, property or constructor to patch + The + + + An annotation that specifies a method, property or constructor to patch + The + + + An annotation that specifies a method, property or constructor to patch + The + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + The + An array of argument types to target overloads + An array of + + + An annotation that specifies a method, property or constructor to patch + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + An array of argument types to target overloads + An array of + + + An annotation that specifies a method, property or constructor to patch + The full name of the declaring class/type + The name of the method, property or constructor to patch + The + + + Annotation to define the original method for delegate injection + + + An annotation that specifies a class to patch + The declaring class/type + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The argument types of the method or constructor to patch + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The name of the method, property or constructor to patch + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The name of the method, property or constructor to patch + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The name of the method, property or constructor to patch + An array of argument types to target overloads + Array of + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The + An array of argument types to target overloads + Array of + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The name of the method, property or constructor to patch + The + + + An annotation that specifies a method, property or constructor to patch + The name of the method, property or constructor to patch + + + An annotation that specifies a method, property or constructor to patch + The name of the method, property or constructor to patch + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + The name of the method, property or constructor to patch + An array of argument types to target overloads + An array of + + + An annotation that specifies a method, property or constructor to patch + The name of the method, property or constructor to patch + The + + + An annotation that specifies call dispatching mechanics for the delegate + The + + + An annotation that specifies a method, property or constructor to patch + The + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + The + An array of argument types to target overloads + An array of + + + An annotation that specifies a method, property or constructor to patch + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + An array of argument types to target overloads + An array of + + + Annotation to define your standin methods for reverse patching + + + An annotation that specifies the type of reverse patching + The of the reverse patch + + + A Harmony annotation to define that all methods in a class are to be patched + + + A Harmony annotation + + + A Harmony annotation to define patch priority + The priority + + + A Harmony annotation + + + A Harmony annotation to define that a patch comes before another patch + The array of harmony IDs of the other patches + + + A Harmony annotation + + + A Harmony annotation to define that a patch comes after another patch + The array of harmony IDs of the other patches + + + A Harmony annotation + + + A Harmony annotation to debug a patch (output uses to log to your Desktop) + + + Specifies the Prepare function in a patch class + + + Specifies the Cleanup function in a patch class + + + Specifies the TargetMethod function in a patch class + + + Specifies the TargetMethods function in a patch class + + + Specifies the Prefix function in a patch class + + + Specifies the Postfix function in a patch class + + + Specifies the Transpiler function in a patch class + + + Specifies the Finalizer function in a patch class + + + A Harmony annotation + + + The name of the original argument + + + The index of the original argument + + + The new name of the original argument + + + An annotation to declare injected arguments by name + + + An annotation to declare injected arguments by index + Zero-based index + + + An annotation to declare injected arguments by renaming them + Name of the original argument + New name + + + An annotation to declare injected arguments by index and renaming them + Zero-based index + New name + + + An abstract wrapper around OpCode and their operands. Used by transpilers + + + The opcode + + + The operand + + + All labels defined on this instruction + + + All exception block boundaries defined on this instruction + + + Creates a new CodeInstruction with a given opcode and optional operand + The opcode + The operand + + + Create a full copy (including labels and exception blocks) of a CodeInstruction + The to copy + + + Clones a CodeInstruction and resets its labels and exception blocks + A lightweight copy of this code instruction + + + Clones a CodeInstruction, resets labels and exception blocks and sets its opcode + The opcode + A copy of this CodeInstruction with a new opcode + + + Clones a CodeInstruction, resets labels and exception blocks and sets its operand + The operand + A copy of this CodeInstruction with a new operand + + + Creates a CodeInstruction calling a method (CALL) + The class/type where the method is declared + The name of the method (case sensitive) + Optional parameters to target a specific overload of the method + Optional list of types that define the generic version of the method + A code instruction that calls the method matching the arguments + + + Creates a CodeInstruction calling a method (CALL) + The target method in the form TypeFullName:MethodName, where the type name matches a form recognized by Type.GetType like Some.Namespace.Type. + Optional parameters to target a specific overload of the method + Optional list of types that define the generic version of the method + A code instruction that calls the method matching the arguments + + + Creates a CodeInstruction calling a method (CALL) + The lambda expression using the method + + + + Creates a CodeInstruction calling a method (CALL) + The lambda expression using the method + + + + Creates a CodeInstruction calling a method (CALL) + The lambda expression using the method + + + + Creates a CodeInstruction calling a method (CALL) + The lambda expression using the method + + + + Returns an instruction to call the specified closure + The delegate type to emit + The closure that defines the method to call + A that calls the closure as a method + + + Creates a CodeInstruction loading a field (LD[S]FLD[A]) + The class/type where the field is defined + The name of the field (case sensitive) + Use address of field + + + + Creates a CodeInstruction storing to a field (ST[S]FLD) + The class/type where the field is defined + The name of the field (case sensitive) + + + + Creates a CodeInstruction loading a local with the given index, using the shorter forms when possible + The index where the local is stored + Use address of local + + + + + Creates a CodeInstruction storing to a local with the given index, using the shorter forms when possible + The index where the local is stored + + + + + Creates a CodeInstruction loading an argument with the given index, using the shorter forms when possible + The index of the argument + Use address of argument + + + + + Creates a CodeInstruction storing to an argument with the given index, using the shorter forms when possible + The index of the argument + + + + + Returns a string representation of the code instruction + A string representation of the code instruction + + + Exception block types + + + The beginning of an exception block + + + The beginning of a catch block + + + The beginning of an except filter block (currently not supported to use in a patch) + + + The beginning of a fault block + + + The beginning of a finally block + + + The end of an exception block + + + An exception block + Creates an exception block + The + The catch type + + + An exception block + Creates an exception block + The + The catch type + + + Block type + + + Catch type + + + The Harmony instance is the main entry to Harmony. After creating one with an unique identifier, it is used to patch and query the current application domain + + + The unique identifier + + + Set to true before instantiating Harmony to debug Harmony or use an environment variable to set HARMONY_DEBUG to '1' like this: cmd /C "set HARMONY_DEBUG=1 && game.exe" + This is for full debugging. To debug only specific patches, use the attribute + + + Creates a new Harmony instance + A unique identifier (you choose your own) + A Harmony instance + + + Searches the current assembly for Harmony annotations and uses them to create patches + This method can fail to use the correct assembly when being inlined. It calls StackTrace.GetFrame(1) which can point to the wrong method/assembly. If you are unsure or run into problems, use PatchAll(Assembly.GetExecutingAssembly()) instead. + + + Creates a empty patch processor for an original method + The original method/constructor + A new instance + + + Creates a patch class processor from an annotated class + The class/type + A new instance + + + Creates a reverse patcher for one of your stub methods + The original method/constructor + The stand-in stub method as + A new instance + + + Searches an assembly for Harmony annotations and uses them to create patches + The assembly + + + Searches an assembly for Harmony-annotated classes without category annotations and uses them to create patches + + + Searches an assembly for Harmony-annotated classes without category annotations and uses them to create patches + The assembly + + + Searches an assembly for Harmony annotations with a specific category and uses them to create patches + Name of patch category + + + Searches an assembly for Harmony annotations with a specific category and uses them to create patches + The assembly + Name of patch category + + + Creates patches by manually specifying the methods + The original method/constructor + An optional prefix method wrapped in a object + An optional postfix method wrapped in a object + An optional transpiler method wrapped in a object + An optional finalizer method wrapped in a object + The replacement method that was created to patch the original method + + + Patches a foreign method onto a stub method of yours and optionally applies transpilers during the process + The original method/constructor you want to duplicate + Your stub method as that will become the original. Needs to have the correct signature (either original or whatever your transpilers generates) + An optional transpiler as method that will be applied during the process + The replacement method that was created to patch the stub method + + + Unpatches methods by patching them with zero patches. Fully unpatching is not supported. Be careful, unpatching is global + The optional Harmony ID to restrict unpatching to a specific Harmony instance + This method could be static if it wasn't for the fact that unpatching creates a new replacement method that contains your harmony ID + + + Unpatches a method by patching it with zero patches. Fully unpatching is not supported. Be careful, unpatching is global + The original method/constructor + The + The optional Harmony ID to restrict unpatching to a specific Harmony instance + + + Unpatches a method by patching it with zero patches. Fully unpatching is not supported. Be careful, unpatching is global + The original method/constructor + The patch method as method to remove + + + Test for patches from a specific Harmony ID + The Harmony ID + True if patches for this ID exist + + + Gets patch information for a given original method + The original method/constructor + The patch information as + + + Gets the methods this instance has patched + An enumeration of original methods/constructors + + + Gets all patched original methods in the appdomain + An enumeration of patched original methods/constructors + + + Gets the original method from a given replacement method + A replacement method (patched original method) + The original method/constructor or null if not found + + + Tries to get the method from a stackframe including dynamic replacement methods + The + For normal frames, frame.GetMethod() is returned. For frames containing patched methods, the replacement method is returned or null if no method can be found + + + Gets the original method from the stackframe and uses original if method is a dynamic replacement + The + The original method from that stackframe + + + Gets Harmony version for all active Harmony instances + [out] The current Harmony version + A dictionary containing assembly versions keyed by Harmony IDs + + + Under Mono, HarmonyException wraps IL compile errors with detailed information about the failure + + + Default serialization constructor (not implemented) + The info + The context + + + Get a list of IL instructions in pairs of offset+code + A list of key/value pairs which represent an offset and the code at that offset + + + Get a list of IL instructions without offsets + A list of + + + Get the error offset of the errornous IL instruction + The offset + + + Get the index of the errornous IL instruction + The index into the list of instructions or -1 if not found + + + A wrapper around a method to use it as a patch (for example a Prefix) + + + The original method + + + Patch Category + + + Class/type declaring this patch + + + Patch method name + + + Optional patch + + + Array of argument types of the patch method + + + + of the patch + + + Install this patch before patches with these Harmony IDs + + + Install this patch after patches with these Harmony IDs + + + Reverse patch type, see + + + Create debug output for this patch + + + Whether to use (true) or (false) mechanics + for -attributed delegate + + + Default constructor + + + Creates a patch from a given method + The original method + + + Creates a patch from a given method + The original method + + + Creates a patch from a given method + The original method + The patch + A list of harmony IDs that should come after this patch + A list of harmony IDs that should come before this patch + Set to true to generate debug output + + + Creates a patch from a given method + The original method + The patch + A list of harmony IDs that should come after this patch + A list of harmony IDs that should come before this patch + Set to true to generate debug output + + + Creates a patch from a given method + The patch class/type + The patch method name + The optional argument types of the patch method (for overloaded methods) + + + Gets the names of all internal patch info fields + A list of field names + + + Merges annotations + The list of to merge + The merged + + + Returns a string that represents the annotation + A string representation + + + Creates a patch from a given method + The original method + + + Creates a patch from a given method + The original method + + + Annotation extensions + + + Copies annotation information + The source + The destination + + + Clones an annotation + The to clone + A copied + + + Merges annotations + The master + The detail + A new, merged + + + Gets all annotations on a class/type + The class/type + A list of all + + + Gets merged annotations on a class/type + The class/type + The merged + + + Gets all annotations on a method + The method/constructor + A list of + + + Gets merged annotations on a method + The method/constructor + The merged + + + + A mutable representation of an inline signature, similar to Mono.Cecil's CallSite. + Used by the calli instruction, can be used by transpilers + + + + See + + + See + + + See + + + The list of all parameter types or function pointer signatures received by the call site + + + The return type or function pointer signature returned by the call site + + + Returns a string representation of the inline signature + A string representation of the inline signature + + + + A mutable representation of a parameter type with an attached type modifier, + similar to Mono.Cecil's OptionalModifierType / RequiredModifierType and C#'s modopt / modreq + + + + Whether this is a modopt (optional modifier type) or a modreq (required modifier type) + + + The modifier type attached to the parameter type + + + The modified parameter type + + + Returns a string representation of the modifier type + A string representation of the modifier type + + + Patch serialization + + + Control the binding of a serialized object to a type + Specifies the assembly name of the serialized object + Specifies the type name of the serialized object + The type of the object the formatter creates a new instance of + + + Serializes a patch info + The + The serialized data + + + Deserialize a patch info + The serialized data + A + + + Compare function to sort patch priorities + The patch + Zero-based index + The priority + A standard sort integer (-1, 0, 1) + + + Serializable patch information + + + Prefixes as an array of + + + Postfixes as an array of + + + Transpilers as an array of + + + Finalizers as an array of + + + Returns if any of the patches wants debugging turned on + + + Adds prefixes + An owner (Harmony ID) + The patch methods + + + Adds a prefix + + + Removes prefixes + The owner of the prefixes, or * for all + + + Adds postfixes + An owner (Harmony ID) + The patch methods + + + Adds a postfix + + + Removes postfixes + The owner of the postfixes, or * for all + + + Adds transpilers + An owner (Harmony ID) + The patch methods + + + Adds a transpiler + + + Removes transpilers + The owner of the transpilers, or * for all + + + Adds finalizers + An owner (Harmony ID) + The patch methods + + + Adds a finalizer + + + Removes finalizers + The owner of the finalizers, or * for all + + + Removes a patch using its method + The method of the patch to remove + + + Gets a concatenated list of patches + The Harmony instance ID adding the new patches + The patches to add + The current patches + + + Gets a list of patches with any from the given owner removed + The owner of the methods, or * for all + The current patches + + + A serializable patch + + + Zero-based index + + + The owner (Harmony ID) + + + The priority, see + + + Keep this patch before the patches indicated in the list of Harmony IDs + + + Keep this patch after the patches indicated in the list of Harmony IDs + + + A flag that will log the replacement method via every time this patch is used to build the replacement, even in the future + + + The method of the static patch method + + + Creates a patch + The method of the patch + Zero-based index + An owner (Harmony ID) + The priority, see + A list of Harmony IDs for patches that should run after this patch + A list of Harmony IDs for patches that should run before this patch + A flag that will log the replacement method via every time this patch is used to build the replacement, even in the future + + + Creates a patch + The method of the patch + Zero-based index + An owner (Harmony ID) + + + Get the patch method or a DynamicMethod if original patch method is a patch factory + The original method/constructor + The method of the patch + + + Determines whether patches are equal + The other patch + true if equal + + + Determines how patches sort + The other patch + integer to define sort order (-1, 0, 1) + + + Hash function + A hash code + + + A PatchClassProcessor used to turn on a class/type into patches + + + Name of the patch class's category + + + Creates a patch class processor by pointing out a class. Similar to PatchAll() but without searching through all classes. + The Harmony instance + The class to process (need to have at least a [HarmonyPatch] attribute) + + + Applies the patches + A list of all created replacement methods or null if patch class is not annotated + + + A group of patches + + + A collection of prefix + + + A collection of postfix + + + A collection of transpiler + + + A collection of finalizer + + + Gets all owners (Harmony IDs) or all known patches + The patch owners + + + Creates a group of patches + An array of prefixes as + An array of postfixes as + An array of transpileres as + An array of finalizeres as + + + A PatchProcessor handles patches on a method/constructor + Creates an empty patch processor + The Harmony instance + The original method/constructor + + + A PatchProcessor handles patches on a method/constructor + Creates an empty patch processor + The Harmony instance + The original method/constructor + + + Adds a prefix + The prefix as a + A for chaining calls + + + Adds a prefix + The prefix method + A for chaining calls + + + Adds a postfix + The postfix as a + A for chaining calls + + + Adds a postfix + The postfix method + A for chaining calls + + + Adds a transpiler + The transpiler as a + A for chaining calls + + + Adds a transpiler + The transpiler method + A for chaining calls + + + Adds a finalizer + The finalizer as a + A for chaining calls + + + Adds a finalizer + The finalizer method + A for chaining calls + + + Gets all patched original methods in the appdomain + An enumeration of patched method/constructor + + + Applies all registered patches + The generated replacement method + + + Unpatches patches of a given type and/or Harmony ID + The patch type + Harmony ID or * for any + A for chaining calls + + + Unpatches a specific patch + The method of the patch + A for chaining calls + + + Gets patch information on an original + The original method/constructor + The patch information as + + + Sort patch methods by their priority rules + The original method + Patches to sort + The sorted patch methods + + + Gets Harmony version for all active Harmony instances + [out] The current Harmony version + A dictionary containing assembly version keyed by Harmony ID + + + Creates a new empty generator to use when reading method bodies + A new + + + Creates a new generator matching the method/constructor to use when reading method bodies + The original method/constructor to copy method information from + A new + + + Returns the methods unmodified list of code instructions + The original method/constructor + Optionally an existing generator that will be used to create all local variables and labels contained in the result (if not specified, an internal generator is used) + A list containing all the original + + + Returns the methods unmodified list of code instructions + The original method/constructor + A new generator that now contains all local variables and labels contained in the result + A list containing all the original + + + Returns the methods current list of code instructions after all existing transpilers have been applied + The original method/constructor + Apply only the first count of transpilers + Optionally an existing generator that will be used to create all local variables and labels contained in the result (if not specified, an internal generator is used) + A list of + + + Returns the methods current list of code instructions after all existing transpilers have been applied + The original method/constructor + A new generator that now contains all local variables and labels contained in the result + Apply only the first count of transpilers + A list of + + + A low level way to read the body of a method. Used for quick searching in methods + The original method + All instructions as opcode/operand pairs + + + A low level way to read the body of a method. Used for quick searching in methods + The original method + An existing generator that will be used to create all local variables and labels contained in the result + All instructions as opcode/operand pairs + + + A patch priority + + + Patch last + + + Patch with very low priority + + + Patch with low priority + + + Patch with lower than normal priority + + + Patch with normal priority + + + Patch with higher than normal priority + + + Patch with high priority + + + Patch with very high priority + + + Patch first + + + A reverse patcher + Creates a reverse patcher + The Harmony instance + The original method/constructor + Your stand-in stub method as + + + A reverse patcher + Creates a reverse patcher + The Harmony instance + The original method/constructor + Your stand-in stub method as + + + Applies the patch + The type of patch, see + The generated replacement method + + + A collection of commonly used transpilers + + + A transpiler that replaces all occurrences of a given method with another one using the same signature + The enumeration of to act on + Method or constructor to search for + Method or constructor to replace with + Modified enumeration of + + + A transpiler that alters instructions that match a predicate by calling an action + The enumeration of to act on + A predicate selecting the instructions to change + An action to apply to matching instructions + Modified enumeration of + + + A transpiler that logs a text at the beginning of the method + The instructions to act on + The log text + Modified enumeration of + + + A helper class for reflection related functions + + + Shortcut for to simplify the use of reflections and make it work for any access level + + + Shortcut for to simplify the use of reflections and make it work for any access level but only within the current type + + + Enumerates all assemblies in the current app domain, excluding visual studio assemblies + An enumeration of + + + Gets a type by name. Prefers a full name with namespace but falls back to the first type matching the name otherwise + The name + A type or null if not found + + + Gets all successfully loaded types from a given assembly + The assembly + An array of types + + This calls and returns , while catching any thrown . + If such an exception is thrown, returns the successfully loaded types (, + filtered for non-null values). + + + + Enumerates all successfully loaded types in the current app domain, excluding visual studio assemblies + An enumeration of all in all assemblies, excluding visual studio assemblies + + + Enumerates all inner types (non-recursive) of a given type + The class/type to start with + An enumeration of all inner + + + Applies a function going up the type hierarchy and stops at the first non-null result + Result type of func() + The class/type to start with + The evaluation function returning T + The first non-null result, or null if no match + + The type hierarchy of a class or value type (including struct) does NOT include implemented interfaces, + and the type hierarchy of an interface is only itself (regardless of whether that interface implements other interfaces). + The top-most type in the type hierarchy of all non-interface types (including value types) is . + + + + Applies a function going into inner types and stops at the first non-null result + Generic type parameter + The class/type to start with + The evaluation function returning T + The first non-null result, or null if no match + + + Creates an identifiable version of a method + The method + + + + Gets the reflection information for a directly declared field + The class/type where the field is defined + The name of the field + A field or null when type/name is null or when the field cannot be found + + + Gets the reflection information for a directly declared field + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A field or null when the field cannot be found + + + Gets the reflection information for a field by searching the type and all its super types + The class/type where the field is defined + The name of the field (case sensitive) + A field or null when type/name is null or when the field cannot be found + + + Gets the reflection information for a field by searching the type and all its super types + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A field or null when the field cannot be found + + + Gets the reflection information for a field + The class/type where the field is declared + The zero-based index of the field inside the class definition + A field or null when type is null or when the field cannot be found + + + Gets the reflection information for a directly declared property + The class/type where the property is declared + The name of the property (case sensitive) + A property or null when type/name is null or when the property cannot be found + + + Gets the reflection information for a directly declared property + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A property or null when the property cannot be found + + + Gets the reflection information for a directly declared indexer property + The class/type where the indexer property is declared + Optional parameters to target a specific overload of multiple indexers + An indexer property or null when type is null or when it cannot be found + + + Gets the reflection information for the getter method of a directly declared property + The class/type where the property is declared + The name of the property (case sensitive) + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the getter method of a directly declared property + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A method or null when the property cannot be found + + + Gets the reflection information for the getter method of a directly declared indexer property + The class/type where the indexer property is declared + Optional parameters to target a specific overload of multiple indexers + A method or null when type is null or when indexer property cannot be found + + + Gets the reflection information for the setter method of a directly declared property + The class/type where the property is declared + The name of the property (case sensitive) + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the Setter method of a directly declared property + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A method or null when the property cannot be found + + + Gets the reflection information for the setter method of a directly declared indexer property + The class/type where the indexer property is declared + Optional parameters to target a specific overload of multiple indexers + A method or null when type is null or when indexer property cannot be found + + + Gets the reflection information for a property by searching the type and all its super types + The class/type + The name + A property or null when type/name is null or when the property cannot be found + + + Gets the reflection information for a property by searching the type and all its super types + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A property or null when the property cannot be found + + + Gets the reflection information for an indexer property by searching the type and all its super types + The class/type + Optional parameters to target a specific overload of multiple indexers + An indexer property or null when type is null or when it cannot be found + + + Gets the reflection information for the getter method of a property by searching the type and all its super types + The class/type + The name + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the getter method of a property by searching the type and all its super types + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the getter method of an indexer property by searching the type and all its super types + The class/type + Optional parameters to target a specific overload of multiple indexers + A method or null when type is null or when the indexer property cannot be found + + + Gets the reflection information for the setter method of a property by searching the type and all its super types + The class/type + The name + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the setter method of a property by searching the type and all its super types + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the setter method of an indexer property by searching the type and all its super types + The class/type + Optional parameters to target a specific overload of multiple indexers + A method or null when type is null or when the indexer property cannot be found + + + Gets the reflection information for a directly declared method + The class/type where the method is declared + The name of the method (case sensitive) + Optional parameters to target a specific overload of the method + Optional list of types that define the generic version of the method + A method or null when type/name is null or when the method cannot be found + + + Gets the reflection information for a directly declared method + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + Optional parameters to target a specific overload of the method + Optional list of types that define the generic version of the method + A method or null when the method cannot be found + + + Gets the reflection information for a method by searching the type and all its super types + The class/type where the method is declared + The name of the method (case sensitive) + Optional parameters to target a specific overload of the method + Optional list of types that define the generic version of the method + A method or null when type/name is null or when the method cannot be found + + + Gets the reflection information for a method by searching the type and all its super types + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + Optional parameters to target a specific overload of the method + Optional list of types that define the generic version of the method + A method or null when the method cannot be found + + + Gets the method of an enumerator method + Enumerator method that creates the enumerator + The internal method of the enumerator or null if no valid enumerator is detected + + + Gets the method of an async method's state machine + Async method that creates the state machine internally + The internal method of the async state machine or null if no valid async method is detected + + + Gets the names of all method that are declared in a type + The declaring class/type + A list of method names + + + Gets the names of all method that are declared in the type of the instance + An instance of the type to search in + A list of method names + + + Gets the names of all fields that are declared in a type + The declaring class/type + A list of field names + + + Gets the names of all fields that are declared in the type of the instance + An instance of the type to search in + A list of field names + + + Gets the names of all properties that are declared in a type + The declaring class/type + A list of property names + + + Gets the names of all properties that are declared in the type of the instance + An instance of the type to search in + A list of property names + + + Gets the type of any class member of + A member + The class/type of this member + + + Test if a class member is actually an concrete implementation + A member + True if the member is a declared + + + Gets the real implementation of a class member + A member + The member itself if its declared. Otherwise the member that is actually implemented in some base type + + + Gets the reflection information for a directly declared constructor + The class/type where the constructor is declared + Optional parameters to target a specific overload of the constructor + Optional parameters to only consider static constructors + A constructor info or null when type is null or when the constructor cannot be found + + + Gets the reflection information for a constructor by searching the type and all its super types + The class/type where the constructor is declared + Optional parameters to target a specific overload of the method + Optional parameters to only consider static constructors + A constructor info or null when type is null or when the method cannot be found + + + Gets reflection information for all declared constructors + The class/type where the constructors are declared + Optional parameters to only consider static constructors + A list of constructor infos + + + Gets reflection information for all declared methods + The class/type where the methods are declared + A list of methods + + + Gets reflection information for all declared properties + The class/type where the properties are declared + A list of properties + + + Gets reflection information for all declared fields + The class/type where the fields are declared + A list of fields + + + Gets the return type of a method or constructor + The method/constructor + The return type + + + Given a type, returns the first inner type matching a recursive search by name + The class/type to start searching at + The name of the inner type (case sensitive) + The inner type or null if type/name is null or if a type with that name cannot be found + + + Given a type, returns the first inner type matching a recursive search with a predicate + The class/type to start searching at + The predicate to search with + The inner type or null if type/predicate is null or if a type with that name cannot be found + + + Given a type, returns the first method matching a predicate + The class/type to start searching at + The predicate to search with + The method or null if type/predicate is null or if a type with that name cannot be found + + + Given a type, returns the first constructor matching a predicate + The class/type to start searching at + The predicate to search with + The constructor info or null if type/predicate is null or if a type with that name cannot be found + + + Given a type, returns the first property matching a predicate + The class/type to start searching at + The predicate to search with + The property or null if type/predicate is null or if a type with that name cannot be found + + + Returns an array containing the type of each object in the given array + An array of objects + An array of types or an empty array if parameters is null (if an object is null, the type for it will be object) + + + Creates an array of input parameters for a given method and a given set of potential inputs + The method/constructor you are planing to call + The possible input parameters in any order + An object array matching the method signature + + + A readable/assignable reference delegate to an instance field of a class or static field (NOT an instance field of a struct) + + An arbitrary type if the field is static; otherwise the class that defines the field, or a parent class (including ), + implemented interface, or derived class of this type + + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The runtime instance to access the field (ignored and can be omitted for static fields) + A readable/assignable reference to the field + Null instance passed to a non-static field ref delegate + + Instance of invalid type passed to a non-static field ref delegate + (this can happen if is a parent class or interface of the field's declaring type) + + + + This delegate cannot be used for instance fields of structs, since a struct instance passed to the delegate would be passed by + value and thus would be a copy that only exists within the delegate's invocation. This is fine for a readonly reference, + but makes assignment futile. Use instead. + + + Note that is not required to be the field's declaring type. It can be a parent class (including ), + implemented interface, or a derived class of the field's declaring type ("instanceOfT is FieldDeclaringType" must be possible). + Specifically, must be assignable from OR to the field's declaring type. + Technically, this allows Nullable, although Nullable is only relevant for structs, and since only static fields of structs + are allowed for this delegate, and the instance passed to such a delegate is ignored, this hardly matters. + + + Similarly, is not required to be the field's field type, unless that type is a non-enum value type. + It can be a parent class (including object) or implemented interface of the field's field type. It cannot be a derived class. + This variance is not allowed for value types, since that would require boxing/unboxing, which is not allowed for ref values. + Special case for enum types: can also be the underlying integral type of the enum type. + Specifically, for reference types, must be assignable from + the field's field type; for non-enum value types, must be exactly the field's field type; for enum types, + must be either the field's field type or the underyling integral type of that field type. + + + This delegate supports static fields, even those defined in structs, for legacy reasons. + For such static fields, is effectively ignored. + Consider using (and StaticFieldRefAccess methods that return it) instead for static fields. + + + + + Creates a field reference delegate for an instance field of a class + The class that defines the instance field, or derived class of this type + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The name of the field + A readable/assignable delegate + + + For backwards compatibility, there is no class constraint on . + Instead, the non-value-type check is done at runtime within the method. + + + + + Creates an instance field reference for a specific instance of a class + The class that defines the instance field, or derived class of this type + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The instance + The name of the field + A readable/assignable reference to the field + + + This method is meant for one-off access to a field's value for a single instance. + If you need to access a field's value for potentially multiple instances, use instead. + FieldRefAccess<T, F>(instance, fieldName) is functionally equivalent to FieldRefAccess<T, F>(fieldName)(instance). + + + For backwards compatibility, there is no class constraint on . + Instead, the non-value-type check is done at runtime within the method. + + + + + Creates a field reference delegate for an instance field of a class or static field (NOT an instance field of a struct) + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + + The type that defines the field, or derived class of this type; must not be a struct type unless the field is static + + The name of the field + + A readable/assignable delegate with T=object + (for static fields, the instance delegate parameter is ignored) + + + + This method is meant for cases where the given type is only known at runtime and thus can't be used as a type parameter T + in e.g. . + + + This method supports static fields, even those defined in structs, for legacy reasons. + Consider using (and other overloads) instead for static fields. + + + + + Creates a field reference delegate for an instance field of a class or static field (NOT an instance field of a struct) + type of the field + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A readable/assignable delegate with T=object + + + Creates a field reference delegate for an instance field of a class or static field (NOT an instance field of a struct) + + An arbitrary type if the field is static; otherwise the class that defines the field, or a parent class (including ), + implemented interface, or derived class of this type ("instanceOfT is FieldDeclaringType" must be possible) + + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The field + A readable/assignable delegate + + + This method is meant for cases where the field has already been obtained, avoiding the field searching cost in + e.g. . + + + This method supports static fields, even those defined in structs, for legacy reasons. + For such static fields, is effectively ignored. + Consider using (and other overloads) instead for static fields. + + + For backwards compatibility, there is no class constraint on . + Instead, the non-value-type check is done at runtime within the method. + + + + + Creates a field reference for an instance field of a class + + The type that defines the field; or a parent class (including ), implemented interface, or derived class of this type + ("instanceOfT is FieldDeclaringType" must be possible) + + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The instance + The field + A readable/assignable reference to the field + + + This method is meant for one-off access to a field's value for a single instance and where the field has already been obtained. + If you need to access a field's value for potentially multiple instances, use instead. + FieldRefAccess<T, F>(instance, fieldInfo) is functionally equivalent to FieldRefAccess<T, F>(fieldInfo)(instance). + + + For backwards compatibility, there is no class constraint on . + Instead, the non-value-type check is done at runtime within the method. + + + + + A readable/assignable reference delegate to an instance field of a struct + The struct that defines the instance field + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + A reference to the runtime instance to access the field + A readable/assignable reference to the field + + + Creates a field reference delegate for an instance field of a struct + The struct that defines the instance field + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The name of the field + A readable/assignable delegate + + + Creates an instance field reference for a specific instance of a struct + The struct that defines the instance field + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The instance + The name of the field + A readable/assignable reference to the field + + + This method is meant for one-off access to a field's value for a single instance. + If you need to access a field's value for potentially multiple instances, use instead. + StructFieldRefAccess<T, F>(ref instance, fieldName) is functionally equivalent to StructFieldRefAccess<T, F>(fieldName)(ref instance). + + + + + Creates a field reference delegate for an instance field of a struct + The struct that defines the instance field + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The field + A readable/assignable delegate + + + This method is meant for cases where the field has already been obtained, avoiding the field searching cost in + e.g. . + + + + + Creates a field reference for an instance field of a struct + The struct that defines the instance field + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The instance + The field + A readable/assignable reference to the field + + + This method is meant for one-off access to a field's value for a single instance and where the field has already been obtained. + If you need to access a field's value for potentially multiple instances, use instead. + StructFieldRefAccess<T, F>(ref instance, fieldInfo) is functionally equivalent to StructFieldRefAccess<T, F>(fieldInfo)(ref instance). + + + + + A readable/assignable reference delegate to a static field + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + A readable/assignable reference to the field + + + Creates a static field reference + The type (can be class or struct) the field is defined in + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The name of the field + A readable/assignable reference to the field + + + Creates a static field reference + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The type (can be class or struct) the field is defined in + The name of the field + A readable/assignable reference to the field + + + Creates a static field reference + The type of the field + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A readable/assignable reference to the field + + + Creates a static field reference + An arbitrary type (by convention, the type the field is defined in) + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The field + A readable/assignable reference to the field + + The type parameter is only used in exception messaging and to distinguish between this method overload + and the overload (which returns a rather than a reference). + + + + Creates a static field reference delegate + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The field + A readable/assignable delegate + + + Creates a delegate to a given method + The delegate Type + The method to create a delegate from. + + Only applies for instance methods. If null (default), returned delegate is an open (a.k.a. unbound) instance delegate + where an instance is supplied as the first argument to the delegate invocation; else, delegate is a closed (a.k.a. bound) + instance delegate where the delegate invocation always applies to the given . + + + Only applies for instance methods. If true (default) and is virtual, invocation of the delegate + calls the instance method virtually (the instance type's most-derived/overriden implementation of the method is called); + else, invocation of the delegate calls the exact specified (this is useful for calling base class methods) + Note: if false and is an interface method, an ArgumentException is thrown. + + A delegate of given to given + + + Delegate invocation is more performant and more convenient to use than + at a one-time setup cost. + + + Works for both type of static and instance methods, both open and closed (a.k.a. unbound and bound) instance methods, + and both class and struct methods. + + + + + Creates a delegate to a given method + The delegate Type + The method in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + + Only applies for instance methods. If null (default), returned delegate is an open (a.k.a. unbound) instance delegate + where an instance is supplied as the first argument to the delegate invocation; else, delegate is a closed (a.k.a. bound) + instance delegate where the delegate invocation always applies to the given . + + + Only applies for instance methods. If true (default) and is virtual, invocation of the delegate + calls the instance method virtually (the instance type's most-derived/overriden implementation of the method is called); + else, invocation of the delegate calls the exact specified (this is useful for calling base class methods) + Note: if false and is an interface method, an ArgumentException is thrown. + + A delegate of given to given + + + Delegate invocation is more performant and more convenient to use than + at a one-time setup cost. + + + Works for both type of static and instance methods, both open and closed (a.k.a. unbound and bound) instance methods, + and both class and struct methods. + + + + + Creates a delegate for a given delegate definition, attributed with [] + The delegate Type, attributed with [] + + Only applies for instance methods. If null (default), returned delegate is an open (a.k.a. unbound) instance delegate + where an instance is supplied as the first argument to the delegate invocation; else, delegate is a closed (a.k.a. bound) + instance delegate where the delegate invocation always applies to the given . + + A delegate of given to the method specified via [] + attributes on + + This calls with the method and virtualCall arguments + determined from the [] attributes on , + and the given (for closed instance delegates). + + + + Returns who called the current method + The calling method/constructor (excluding the caller) + + + Rethrows an exception while preserving its stack trace (throw statement typically clobbers existing stack traces) + The exception to rethrow + + + True if the current runtime is based on Mono, false otherwise (.NET) + + + True if the current runtime is .NET Framework, false otherwise (.NET Core or Mono, although latter isn't guaranteed) + + + True if the current runtime is .NET Core, false otherwise (Mono or .NET Framework) + + + Throws a missing member runtime exception + The type that is involved + A list of names + + + Gets default value for a specific type + The class/type + The default value + + + Creates an (possibly uninitialized) instance of a given type + The class/type + The new instance + + + Creates an (possibly uninitialized) instance of a given type + The class/type + The new instance + + + + A cache for the or similar Add methods for different types. + + + + Makes a deep copy of any object + The type of the instance that should be created; for legacy reasons, this must be a class or interface + The original object + A copy of the original object but of type T + + + Makes a deep copy of any object + The type of the instance that should be created + The original object + [out] The copy of the original object + Optional value transformation function (taking a field name and src/dst instances) + The optional path root to start with + + + Makes a deep copy of any object + The original object + The type of the instance that should be created + Optional value transformation function (taking a field name and src/dst instances) + The optional path root to start with + The copy of the original object + + + Tests if a type is a struct + The type + True if the type is a struct + + + Tests if a type is a class + The type + True if the type is a class + + + Tests if a type is a value type + The type + True if the type is a value type + + + Tests if a type is an integer type + The type + True if the type represents some integer + + + Tests if a type is a floating point type + The type + True if the type represents some floating point + + + Tests if a type is a numerical type + The type + True if the type represents some number + + + Tests if a type is void + The type + True if the type is void + + + Test whether an instance is of a nullable type + Type of instance + An instance to test + True if instance is of nullable type, false if not + + + Tests whether a type or member is static, as defined in C# + The type or member + True if the type or member is static + + + Tests whether a type is static, as defined in C# + The type + True if the type is static + + + Tests whether a property is static, as defined in C# + The property + True if the property is static + + + Tests whether an event is static, as defined in C# + The event + True if the event is static + + + Calculates a combined hash code for an enumeration of objects + The objects + The hash code + + + Adds extensions to Type for a lot of AccessTools methods + + + Enumerates all inner types (non-recursive) + The class/type to start with + An enumeration of all inner + + + Applies a function going up the type hierarchy and stops at the first non-null result + Result type of func() + The class/type to start with + The evaluation function returning T + The first non-null result, or null if no match + + The type hierarchy of a class or value type (including struct) does NOT include implemented interfaces, + and the type hierarchy of an interface is only itself (regardless of whether that interface implements other interfaces). + The top-most type in the type hierarchy of all non-interface types (including value types) is . + + + + Applies a function going into inner types and stops at the first non-null result + Generic type parameter + The class/type to start with + The evaluation function returning T + The first non-null result, or null if no match + + + Gets the reflection information for a directly declared field + The class/type where the field is defined + The name of the field + A field or null when type/name is null or when the field cannot be found + + + Gets the reflection information for a field by searching the type and all its super types + The class/type where the field is defined + The name of the field (case sensitive) + A field or null when type/name is null or when the field cannot be found + + + Gets the reflection information for a field + The class/type where the field is declared + The zero-based index of the field inside the class definition + A field or null when type is null or when the field cannot be found + + + Gets the reflection information for a directly declared property + The class/type where the property is declared + The name of the property (case sensitive) + A property or null when type/name is null or when the property cannot be found + + + Gets the reflection information for a directly declared indexer property + The class/type where the indexer property is declared + Optional parameters to target a specific overload of multiple indexers + An indexer property or null when type is null or when it cannot be found + + + Gets the reflection information for the getter method of a directly declared property + The class/type where the property is declared + The name of the property (case sensitive) + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the getter method of a directly declared indexer property + The class/type where the indexer property is declared + Optional parameters to target a specific overload of multiple indexers + A method or null when type is null or when indexer property cannot be found + + + Gets the reflection information for the setter method of a directly declared property + The class/type where the property is declared + The name of the property (case sensitive) + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the setter method of a directly declared indexer property + The class/type where the indexer property is declared + Optional parameters to target a specific overload of multiple indexers + A method or null when type is null or when indexer property cannot be found + + + Gets the reflection information for a property by searching the type and all its super types + The class/type + The name + A property or null when type/name is null or when the property cannot be found + + + Gets the reflection information for an indexer property by searching the type and all its super types + The class/type + Optional parameters to target a specific overload of multiple indexers + An indexer property or null when type is null or when it cannot be found + + + Gets the reflection information for the getter method of a property by searching the type and all its super types + The class/type + The name + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the getter method of an indexer property by searching the type and all its super types + The class/type + Optional parameters to target a specific overload of multiple indexers + A method or null when type is null or when the indexer property cannot be found + + + Gets the reflection information for the setter method of a property by searching the type and all its super types + The class/type + The name + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the setter method of an indexer property by searching the type and all its super types + The class/type + Optional parameters to target a specific overload of multiple indexers + A method or null when type is null or when the indexer property cannot be found + + + Gets the reflection information for a directly declared method + The class/type where the method is declared + The name of the method (case sensitive) + Optional parameters to target a specific overload of the method + Optional list of types that define the generic version of the method + A method or null when type/name is null or when the method cannot be found + + + Gets the reflection information for a method by searching the type and all its super types + The class/type where the method is declared + The name of the method (case sensitive) + Optional parameters to target a specific overload of the method + Optional list of types that define the generic version of the method + A method or null when type/name is null or when the method cannot be found + + + Gets the names of all method that are declared in a type + The declaring class/type + A list of method names + + + Gets the names of all fields that are declared in a type + The declaring class/type + A list of field names + + + Gets the names of all properties that are declared in a type + The declaring class/type + A list of property names + + + Gets the reflection information for a directly declared constructor + The class/type where the constructor is declared + Optional parameters to target a specific overload of the constructor + Optional parameters to only consider static constructors + A constructor info or null when type is null or when the constructor cannot be found + + + Gets the reflection information for a constructor by searching the type and all its super types + The class/type where the constructor is declared + Optional parameters to target a specific overload of the method + Optional parameters to only consider static constructors + A constructor info or null when type is null or when the method cannot be found + + + Gets reflection information for all declared constructors + The class/type where the constructors are declared + Optional parameters to only consider static constructors + A list of constructor infos + + + Gets reflection information for all declared methods + The class/type where the methods are declared + A list of methods + + + Gets reflection information for all declared properties + The class/type where the properties are declared + A list of properties + + + Gets reflection information for all declared fields + The class/type where the fields are declared + A list of fields + + + Given a type, returns the first inner type matching a recursive search by name + The class/type to start searching at + The name of the inner type (case sensitive) + The inner type or null if type/name is null or if a type with that name cannot be found + + + Given a type, returns the first inner type matching a recursive search with a predicate + The class/type to start searching at + The predicate to search with + The inner type or null if type/predicate is null or if a type with that name cannot be found + + + Given a type, returns the first method matching a predicate + The class/type to start searching at + The predicate to search with + The method or null if type/predicate is null or if a type with that name cannot be found + + + Given a type, returns the first constructor matching a predicate + The class/type to start searching at + The predicate to search with + The constructor info or null if type/predicate is null or if a type with that name cannot be found + + + Given a type, returns the first property matching a predicate + The class/type to start searching at + The predicate to search with + The property or null if type/predicate is null or if a type with that name cannot be found + + + Creates a field reference delegate for an instance field of a class or static field (NOT an instance field of a struct) + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + + The type that defines the field, or derived class of this type; must not be a struct type unless the field is static + + The name of the field + + A readable/assignable delegate with T=object + (for static fields, the instance delegate parameter is ignored) + + + + This method is meant for cases where the given type is only known at runtime and thus can't be used as a type parameter T + in e.g. . + + + This method supports static fields, even those defined in structs, for legacy reasons. + Consider using (and other overloads) instead for static fields. + + + + + Creates a static field reference + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The type (can be class or struct) the field is defined in + The name of the field + A readable/assignable reference to the field + + + Throws a missing member runtime exception + The type that is involved + A list of names + + + Gets default value for a specific type + The class/type + The default value + + + Creates an (possibly uninitialized) instance of a given type + The class/type + The new instance + + + Tests if a type is a struct + The type + True if the type is a struct + + + Tests if a type is a class + The type + True if the type is a class + + + Tests if a type is a value type + The type + True if the type is a value type + + + Tests if a type is an integer type + The type + True if the type represents some integer + + + Tests if a type is a floating point type + The type + True if the type represents some floating point + + + Tests if a type is a numerical type + The type + True if the type represents some number + + + Tests if a type is void + The type + True if the type is void + + + Tests whether a type is static, as defined in C# + The type + True if the type is static + + + + By adding the following using statement to your source code: using static HarmonyLib.Code; + you can for example start using Ldarg_1 in you code instead of new CodeMatch(OpCodes.Ldarg_1) + and then you can use array notation to add an operand and/or a name: Call[myMethodInfo] instead of new CodeMatch(OpCodes.Call, myMethodInfo) + + + A CodeInstruction match + + + The name of the match + + + The matched opcodes + + + The matched opcodes + + + The matched operands + + + The jumps from the match + + + The jumps to the match + + + The match predicate + + + Creates a code match + The optional opcode + The optional operand + The optional name + + + Creates a code match + The opcodes + The optional operand + The optional name + + + Creates a code match that calls a method + The lambda expression using the method + The optional name + + + Creates a code match that calls a method + The lambda expression using the method + The optional name + + + Creates a code match + The CodeInstruction + An optional name + + + Creates a code match + The predicate + An optional name + + + Tests for any form of Ldarg* + The (optional) index + A new code match + + + Tests for Ldarga/Ldarga_S + The (optional) index + A new code match + + + Tests for Starg/Starg_S + The (optional) index + A new code match + + + Tests for any form of Ldloc* + The optional local variable + A new code match + + + Tests for any form of Stloc* + The optional local variable + A new code match + + + Tests if the code instruction calls the method/constructor + The method + A new code match + + + Tests if the code instruction loads a constant + A new code match + + + Tests if the code instruction loads an integer constant + The integer constant + A new code match + + + Tests if the code instruction loads a floating point constant + The floating point constant + A new code match + + + Tests if the code instruction loads an enum constant + The enum + A new code match + + + Tests if the code instruction loads a string constant + The string + A new code match + + + Tests if the code instruction loads a field + The field + Set to true if the address of the field is loaded + A new code match + + + Tests if the code instruction stores a field + The field + A new code match + + + Creates a code match that calls a method + The lambda expression using the method + A new code match + + + Creates a code match that calls a method + The lambda expression using the method + A new code match + + + Creates a code match for local loads + Whether to match for address loads + An optional name + A new code match + + + Creates a code match for local stores + An optional name + A new code match + + + Creates a code match for argument loads + Whether to match for address loads + An optional name + A new code match + + + Creates a code match for argument stores + An optional name + A new code match + + + Creates a code match for branching + An optional name + A new code match + + + Returns a string that represents the match + A string representation + + + A CodeInstruction matcher + + + The current position + The index or -1 if out of bounds + + + Gets the number of code instructions in this matcher + The count + + + Checks whether the position of this CodeMatcher is within bounds + True if this CodeMatcher is valid + + + Checks whether the position of this CodeMatcher is outside its bounds + True if this CodeMatcher is invalid + + + Gets the remaining code instructions + The remaining count + + + Gets the opcode at the current position + The opcode + + + Gets the operand at the current position + The operand + + + Gets the labels at the current position + The labels + + + Gets the exception blocks at the current position + The blocks + + + Creates an empty code matcher + + + Creates a code matcher from an enumeration of instructions + The instructions (transpiler argument) + An optional IL generator + + + Makes a clone of this instruction matcher + A copy of this matcher + + + Gets instructions at the current position + The instruction + + + Gets instructions at the current position with offset + The offset + The instruction + + + Gets all instructions + A list of instructions + + + Gets all instructions as an enumeration + A list of instructions + + + Gets some instructions counting from current position + Number of instructions + A list of instructions + + + Gets all instructions within a range + The start index + The end index + A list of instructions + + + Gets all instructions within a range (relative to current position) + The start offset + The end offset + A list of instructions + + + Gets a list of all distinct labels + The instructions (transpiler argument) + A list of Labels + + + Reports a failure + The method involved + The logger + True if current position is invalid and error was logged + + + Throw an InvalidOperationException if current state is invalid (position out of bounds / last match failed) + Explanation of where/why the exception was thrown that will be added to the exception message + The same code matcher + + + Throw an InvalidOperationException if current state is invalid (position out of bounds / last match failed), + or if the matches do not match at current position + Explanation of where/why the exception was thrown that will be added to the exception message + Some code matches + The same code matcher + + + Throw an InvalidOperationException if current state is invalid (position out of bounds / last match failed), + or if the matches do not match at any point between current position and the end + Explanation of where/why the exception was thrown that will be added to the exception message + Some code matches + The same code matcher + + + Throw an InvalidOperationException if current state is invalid (position out of bounds / last match failed), + or if the matches do not match at any point between current position and the start + Explanation of where/why the exception was thrown that will be added to the exception message + Some code matches + The same code matcher + + + Throw an InvalidOperationException if current state is invalid (position out of bounds / last match failed), + or if the check function returns false + Explanation of where/why the exception was thrown that will be added to the exception message + Function that checks validity of current state. If it returns false, an exception is thrown + The same code matcher + + + Sets an instruction at current position + The instruction to set + The same code matcher + + + Sets instruction at current position and advances + The instruction + The same code matcher + + + Sets opcode and operand at current position + The opcode + The operand + The same code matcher + + + Sets opcode and operand at current position and advances + The opcode + The operand + The same code matcher + + + Sets opcode at current position and advances + The opcode + The same code matcher + + + Sets operand at current position and advances + The operand + The same code matcher + + + Declares a local variable but does not add it + The variable type + [out] The new local variable + The same code matcher + + + Declares a new label but does not add it + [out] The new label + The same code matcher + + + Creates a label at current position + [out] The label + The same code matcher + + + Creates a label at a position + The position + [out] The new label + The same code matcher + + + Creates a label at a position + The offset + [out] The new label + The same code matcher + + + Adds an enumeration of labels to current position + The labels + The same code matcher + + + Adds an enumeration of labels at a position + The position + The labels + The same code matcher + + + Sets jump to + Branch instruction + Destination for the jump + [out] The created label + The same code matcher + + + Inserts some instructions + The instructions + The same code matcher + + + Inserts an enumeration of instructions + The instructions + The same code matcher + + + Inserts a branch + The branch opcode + Branch destination + The same code matcher + + + Inserts some instructions and advances the position + The instructions + The same code matcher + + + Inserts an enumeration of instructions and advances the position + The instructions + The same code matcher + + + Inserts a branch and advances the position + The branch opcode + Branch destination + The same code matcher + + + Removes current instruction + The same code matcher + + + Removes some instruction from current position by count + Number of instructions + The same code matcher + + + Removes the instructions in a range + The start + The end + The same code matcher + + + Removes the instructions in a offset range + The start offset + The end offset + The same code matcher + + + Advances the current position + The offset + The same code matcher + + + Moves the current position to the start + The same code matcher + + + Moves the current position to the end + The same code matcher + + + Searches forward with a predicate and advances position + The predicate + The same code matcher + + + Searches backwards with a predicate and reverses position + The predicate + The same code matcher + + + Matches forward and advances position to beginning of matching sequence + Some code matches + The same code matcher + + + Matches forward and advances position to ending of matching sequence + Some code matches + The same code matcher + + + Matches backwards and reverses position to beginning of matching sequence + Some code matches + The same code matcher + + + Matches backwards and reverses position to ending of matching sequence + Some code matches + The same code matcher + + + Repeats a match action until boundaries are met + The match action + An optional action that is executed when no match is found + The same code matcher + + + Gets a match by its name + The match name + An instruction + + + General extensions for common cases + + + Joins an enumeration with a value converter and a delimiter to a string + The inner type of the enumeration + The enumeration + An optional value converter (from T to string) + An optional delimiter + The values joined into a string + + + Converts an array of types (for example methods arguments) into a human readable form + The array of types + A human readable description including brackets + + + A full description of a type + The type + A human readable description + + + A a full description of a method or a constructor without assembly details but with generics + The method/constructor + A human readable description + + + A helper converting parameter infos to types + The array of parameter infos + An array of types + + + A helper to access a value via key from a dictionary + The key type + The value type + The dictionary + The key + The value for the key or the default value (of T) if that key does not exist + + + A helper to access a value via key from a dictionary with extra casting + The value type + The dictionary + The key + The value for the key or the default value (of T) if that key does not exist or cannot be cast to T + + + Escapes Unicode and ASCII non printable characters + The string to convert + The string to convert + A string literal surrounded by + + + Extensions for + + + Returns if an is initialized and valid + The + + + + Shortcut for testing whether the operand is equal to a non-null value + The + The value + True if the operand has the same type and is equal to the value + + + Shortcut for testing whether the operand is equal to a non-null value + The + The value + True if the operand is equal to the value + This is an optimized version of for + + + Shortcut for code.opcode == opcode && code.OperandIs(operand) + The + The + The operand value + True if the opcode is equal to the given opcode and the operand has the same type and is equal to the given operand + + + Shortcut for code.opcode == opcode && code.OperandIs(operand) + The + The + The operand value + True if the opcode is equal to the given opcode and the operand is equal to the given operand + This is an optimized version of for + + + Tests for any form of Ldarg* + The + The (optional) index + True if it matches one of the variations + + + Tests for Ldarga/Ldarga_S + The + The (optional) index + True if it matches one of the variations + + + Tests for Starg/Starg_S + The + The (optional) index + True if it matches one of the variations + + + Tests for any form of Ldloc* + The + The optional local variable + True if it matches one of the variations + + + Tests for any form of Stloc* + The + The optional local variable + True if it matches one of the variations + + + Tests if the code instruction branches + The + The label if the instruction is a branch operation or if not + True if the instruction branches + + + Tests if the code instruction calls the method/constructor + The + The method + True if the instruction calls the method or constructor + + + Tests if the code instruction loads a constant + The + True if the instruction loads a constant + + + Tests if the code instruction loads an integer constant + The + The integer constant + True if the instruction loads the constant + + + Tests if the code instruction loads a floating point constant + The + The floating point constant + True if the instruction loads the constant + + + Tests if the code instruction loads an enum constant + The + The enum + True if the instruction loads the constant + + + Tests if the code instruction loads a string constant + The + The string + True if the instruction loads the constant + + + Tests if the code instruction loads a field + The + The field + Set to true if the address of the field is loaded + True if the instruction loads the field + + + Tests if the code instruction stores a field + The + The field + True if the instruction stores this field + + + Returns the index targeted by this ldloc, ldloca, or stloc + The + The index it targets + + + + + Returns the index targeted by this ldarg, ldarga, or starg + The + The index it targets + + + + + Adds labels to the code instruction and return it + The + One or several to add + The same code instruction + + + Adds labels to the code instruction and return it + The + An enumeration of + The same code instruction + + + Extracts all labels from the code instruction and returns them + The + A list of + + + Moves all labels from the code instruction to another one + The to move the labels from + The other to move the labels to + The code instruction labels were moved from (now empty) + + + Moves all labels from another code instruction to the current one + The to move the labels to + The other to move the labels from + The code instruction that received the labels + + + Adds ExceptionBlocks to the code instruction and return it + The + One or several to add + The same code instruction + + + Adds ExceptionBlocks to the code instruction and return it + The + An enumeration of + The same code instruction + + + Extracts all ExceptionBlocks from the code instruction and returns them + The + A list of + + + Moves all ExceptionBlocks from the code instruction to another one + The to move the ExceptionBlocks from + The other to move the ExceptionBlocks to + The code instruction blocks were moved from (now empty) + + + Moves all ExceptionBlocks from another code instruction to the current one + The to move the ExceptionBlocks to + The other to move the ExceptionBlocks from + The code instruction that received the blocks + + + Extensions for a sequence of + + + Searches a list of by running a sequence of against it + The CodeInstructions (like a body of a method) to search in + An array of representing the sequence of codes you want to search for + + + + General extensions for collections + + + A simple way to execute code for every element in a collection + The inner type of the collection + The collection + The action to execute + + + A simple way to execute code for elements in a collection matching a condition + The inner type of the collection + The collection + The predicate + The action to execute + + + A helper to add an item to a collection + The inner type of the collection + The collection + The item to add + The collection containing the item + + + A helper to add an item to an array + The inner type of the collection + The array + The item to add + The array containing the item + + + A helper to add items to an array + The inner type of the collection + The array + The items to add + The array containing the items + + + General extensions for collections + + + Tests a class member if it has an IL method body (external methods for example don't have a body) + The member to test + Returns true if the member has an IL body or false if not + + + A file log for debugging + + + Set this to make Harmony write its log content to this stream + + + Full pathname of the log file, defaults to a file called harmony.log.txt on your Desktop + + + The indent character. The default is tab + + + The current indent level + + + Changes the indentation level + The value to add to the indentation level + + + Log a string in a buffered way. Use this method only if you are sure that FlushBuffer will be called + or else logging information is incomplete in case of a crash + The string to log + + + Logs a list of string in a buffered way. Use this method only if you are sure that FlushBuffer will be called + or else logging information is incomplete in case of a crash + A list of strings to log (they will not be re-indented) + + + Returns the log buffer and optionally empties it + True to empty the buffer + The buffer. + + + Replaces the buffer with new lines + The lines to store + + + Flushes the log buffer to disk (use in combination with LogBuffered) + + + Log a string directly to disk. Slower method that prevents missing information in case of a crash + The string to log. + + + Log a string directly to disk if Harmony.DEBUG is true. Slower method that prevents missing information in case of a crash + The string to log. + + + Resets and deletes the log + + + Logs some bytes as hex values + The pointer to some memory + The length of bytes to log + + + A helper class to retrieve reflection info for non-private methods + + + Given a lambda expression that calls a method, returns the method info + The lambda expression using the method + The method in the lambda expression + + + Given a lambda expression that calls a method, returns the method info + The generic type + The lambda expression using the method + The method in the lambda expression + + + Given a lambda expression that calls a method, returns the method info + The generic type + The generic result type + The lambda expression using the method + The method in the lambda expression + + + Given a lambda expression that calls a method, returns the method info + The lambda expression using the method + The method in the lambda expression + + + A reflection helper to read and write private elements + The result type defined by GetValue() + + + Creates a traverse instance from an existing instance + The existing instance + + + Gets/Sets the current value + The value to read or write + + + A reflection helper to read and write private elements + + + Creates a new traverse instance from a class/type + The class/type + A instance + + + Creates a new traverse instance from a class T + The class + A instance + + + Creates a new traverse instance from an instance + The object + A instance + + + Creates a new traverse instance from a named type + The type name, for format see + A instance + + + Creates a new and empty traverse instance + + + Creates a new traverse instance from a class/type + The class/type + + + Creates a new traverse instance from an instance + The object + + + Gets the current value + The value + + + Gets the current value + The type of the value + The value + + + Invokes the current method with arguments and returns the result + The method arguments + The value returned by the method + + + Invokes the current method with arguments and returns the result + The type of the value + The method arguments + The value returned by the method + + + Sets a value of the current field or property + The value + The same traverse instance + + + Gets the type of the current field or property + The type + + + Moves the current traverse instance to a inner type + The type name + A traverse instance + + + Moves the current traverse instance to a field + The type name + A traverse instance + + + Moves the current traverse instance to a field + The type of the field + The type name + A traverse instance + + + Gets all fields of the current type + A list of field names + + + Moves the current traverse instance to a property + The type name + Optional property index + A traverse instance + + + Moves the current traverse instance to a field + The type of the property + The type name + Optional property index + A traverse instance + + + Gets all properties of the current type + A list of property names + + + Moves the current traverse instance to a method + The name of the method + The arguments defining the argument types of the method overload + A traverse instance + + + Moves the current traverse instance to a method + The name of the method + The argument types of the method + The arguments for the method + A traverse instance + + + Gets all methods of the current type + A list of method names + + + Checks if the current traverse instance is for a field + True if its a field + + + Checks if the current traverse instance is for a property + True if its a property + + + Checks if the current traverse instance is for a method + True if its a method + + + Checks if the current traverse instance is for a type + True if its a type + + + Iterates over all fields of the current type and executes a traverse action + Original object + The action receiving a instance for each field + + + Iterates over all fields of the current type and executes a traverse action + Original object + Target object + The action receiving a pair of instances for each field pair + + + Iterates over all fields of the current type and executes a traverse action + Original object + Target object + The action receiving a dot path representing the field pair and the instances + + + Iterates over all properties of the current type and executes a traverse action + Original object + The action receiving a instance for each property + + + Iterates over all properties of the current type and executes a traverse action + Original object + Target object + The action receiving a pair of instances for each property pair + + + Iterates over all properties of the current type and executes a traverse action + Original object + Target object + The action receiving a dot path representing the property pair and the instances + + + A default field action that copies fields to fields + + + Returns a string that represents the current traverse + A string representation + + + \ No newline at end of file diff --git a/1.5/Assemblies/DubsMintMenus.dll b/1.5/Assemblies/DubsMintMenus.dll new file mode 100644 index 0000000..12f0023 Binary files /dev/null and b/1.5/Assemblies/DubsMintMenus.dll differ diff --git a/1.5/Defs/MainButtons.xml b/1.5/Defs/MainButtons.xml new file mode 100644 index 0000000..942b104 --- /dev/null +++ b/1.5/Defs/MainButtons.xml @@ -0,0 +1,135 @@ + + + + MintMenus + + Search all buildings of all mods. + DubsMintMenus.MainTabWindow_MintArchitect + false + None + + + + MintResearch + + Search research projects. + DubsMintMenus.MainTabWindow_MintResearch + false + None + + + + MintDesignators + + Quick select designators. + DubsMintMenus.MainTabWindow_MayaMenu + false + None + + + + MintBillMenu + + View all bills. + DubsMintMenus.MainTabWindow_MintBillMenu + DubsMintMenus.MainButtonWorker_MintBillMenu + true + None + 100 + True + Mint/UI/Global_bills + false + + + + + + + + MintGearMenu + + View all pawns gear. + + DubsMintMenus.MintPawns_GearButton + None + 100 + True + Mint/UI/Parka + false + + + + + + + + + + MintMenus + + Keybinds for Dubs Mint Menus. + true + + + + MintMenus + MintMenus_BuildMenu + + + + + MintMenus + MintMenus_MintResearch + + + + + MintMenus + MintMenus_MintWheel + + + + + MintMenus + MintMenus_MintBillMenu + + + + + MintMenus + MintMenus_PinningHide + + + + + MintMenus + MintMenus_MintGearMenu + + + + + diff --git a/About/About.xml b/About/About.xml index 0ea0b7e..cf1ebc9 100644 --- a/About/About.xml +++ b/About/About.xml @@ -3,6 +3,8 @@ Dubs Mint Menus Dubwise + Mint/UI/Logo + 1.3.1086 https://github.com/Dubwise56/Dubs-Mint-Menus
  • 1.0
    • @@ -10,6 +12,7 @@
  • 1.2
  • 1.3
  • 1.4
    • +
  • 1.5
    •  Dubwise.DubsMintMenus Adds new list boxes for recipe bills, health bills, plant selection, architect menu, research menu, and a quick select menu for designators, making it easier to find things when lots of mods are running. diff --git a/Textures/Mint/UI/Logo.png b/Textures/Mint/UI/Logo.png new file mode 100644 index 0000000..57bd590 Binary files /dev/null and b/Textures/Mint/UI/Logo.png differ