diff --git a/1.2/Assemblies/0Harmony.dll b/1.2/Assemblies/0Harmony.dll
new file mode 100644
index 0000000..947c81c
Binary files /dev/null and b/1.2/Assemblies/0Harmony.dll differ
diff --git a/1.2/Assemblies/0Harmony.xml b/1.2/Assemblies/0Harmony.xml
new file mode 100644
index 0000000..6bcea2e
--- /dev/null
+++ b/1.2/Assemblies/0Harmony.xml
@@ -0,0 +1,2900 @@
+
+
+
+ 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.
+
+
+
+
+ A low level memory helper
+
+
+ Mark method for no inlining (currently only works on Mono)
+ The method/constructor to change
+
+
+ Detours a method
+ The original method/constructor
+ The replacement method/constructor
+ An error string
+
+
+
+ Writes a jump to memory
+ The memory address
+ Jump destination
+ An error string
+
+
+
+ Gets the start of a method in memory
+ The method/constructor
+ [out] Details of the exception
+ The method start address
+
+
+
+ special parameter names that can be used in prefix and postfix methods
+
+
+ Patch function helpers
+
+
+ Adds a prefix
+ The patch info
+ The owner (Harmony ID)
+ The annotation info
+
+
+
+ Removes a prefix
+ The patch info
+ The owner (Harmony ID)
+
+
+
+ Adds a postfix
+ The patch info
+ The owner (Harmony ID)
+ The annotation info
+
+
+
+ Removes a postfix
+ The patch info
+ The owner (Harmony ID)
+
+
+
+ Adds a transpiler
+ The patch info
+ The owner (Harmony ID)
+ The annotation info
+
+
+
+ Removes a transpiler
+ The patch info
+ The owner (Harmony ID)
+
+
+
+ Adds a finalizer
+ The patch info
+ The owner (Harmony ID)
+ The annotation info
+
+
+
+ Removes a finalizer
+ The patch info
+ The owner (Harmony ID)
+
+
+
+ Removes a patch method
+ The patch info
+ The patch method
+
+
+
+ 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
+
+
+ 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 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
+
+
+
+ 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
+
+
+
+
+ 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)
+
+
+
+ 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
+
+
+
+ The beginning of a fault block
+
+
+
+ The beginning of a finally block
+
+
+
+ The end of an exception block
+
+
+
+ An exception block
+
+
+
+ Block type
+
+
+
+ Catch type
+
+
+
+ Creates an exception block
+ The
+ The 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
+
+
+
+ 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
+
+
+
+ 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 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
+
+
+
+ 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
+ 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
+
+
+
+ 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
+
+
+
+ Default constructor
+
+
+
+ Returns if any of the patches wants debugging turned on
+
+
+
+ Adds a prefix
+
+ The prefix method
+ An owner (Harmony ID)
+ The priority, see
+ A list of Harmony IDs for prefixes that should run after this prefix
+ A list of Harmony IDs for prefixes that should run before this prefix
+ A flag that will log the replacement method via every time this prefix is used to build the replacement, even in the future
+
+
+
+ Removes prefixes
+ The owner of the prefix or * for any prefix
+
+
+
+ Adds a postfix
+ The postfix method
+ An owner (Harmony ID)
+ The priority, see
+ A list of Harmony IDs for postfixes that should run after this postfix
+ A list of Harmony IDs for postfixes that should run before this postfix
+ A flag that will log the replacement method via every time this postfix is used to build the replacement, even in the future
+
+
+
+ Removes postfixes
+ The owner of the postfix or * for any postfix
+
+
+
+ Adds a transpiler
+ The transpiler method
+ An owner (Harmony ID)
+ The priority, see
+ A list of Harmony IDs for transpilers that should run after this transpiler
+ A list of Harmony IDs for transpilers that should run before this transpiler
+ A flag that will log the replacement method via every time this patch is used to build the replacement, even in the future
+
+
+
+ Removes transpilers
+ The owner of the transpiler or * for any transpiler
+
+
+
+ Adds a finalizer
+ The finalizer method
+ An owner (Harmony ID)
+ The priority, see
+ A list of Harmony IDs for finalizers that should run after this finalizer
+ A list of Harmony IDs for finalizers that should run before this finalizer
+ A flag that will log the replacement method via every time this patch is used to build the replacement, even in the future
+
+
+
+ Removes finalizers
+ The owner of the finalizer or * for any finalizer
+
+
+
+ Removes a patch using its method
+ The method of the patch to remove
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+ 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
+ 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
+
+
+
+ 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).
+
+
+
+
+ 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
+ Returns the first non null result or default(T) when reaching the top level type object
+
+
+
+ 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
+ Returns the first non null result or null with 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 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 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 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 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 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 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 reflection information for a method by searching the type and all its super types
+ 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 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 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 read/writable reference to an instance field
+ The class the field is defined in or "object" if type cannot be accessed at compile time
+ The type of the field
+ The runtime instance to access the field (leave empty for static fields)
+ An readable/assignable object representing the field
+
+
+
+ Creates an instance field reference
+ The class the field is defined in
+ The type of the field
+ The name of the field
+ A read and writable field reference delegate
+
+
+
+ Creates an instance field reference for a specific instance
+ The class the field is defined in
+ The type of the field
+ The instance
+ The name of the field
+ An readable/assignable object representing the field
+
+
+
+ Creates an instance field reference delegate for a private type
+ The type of the field
+ The class/type
+ The name of the field
+ A read and writable delegate
+
+
+
+ Creates an instance field reference delegate for a fieldinfo
+ The class the field is defined in or "object" if type cannot be accessed at compile time
+ The type of the field
+ The field of the field
+ A read and writable delegate
+
+
+
+ Creates a static field reference
+ The class the field is defined in or "object" if type cannot be accessed at compile time
+ The type of the field
+ The name of the field
+ An readable/assignable object representing the static field
+
+
+
+ Creates a static field reference
+ The type of the field
+ The class/type
+ The name of the field
+ An readable/assignable object representing the static field
+
+
+
+ Creates a static field reference
+ The class the field is defined in or "object" if type cannot be accessed at compile time
+ The type of the field
+ The field
+ An readable/assignable object representing the static field
+
+
+
+ A read/writable reference delegate to a static field
+ The type of the field
+ An readable/assignable object representing the static field
+
+
+
+ Creates a static field reference delegate
+ The type of the field
+ The field
+ A read and writable 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 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
+
+
+
+ Makes a deep copy of any object
+ The type of the instance that should be created
+ 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
+
+
+
+ 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
+
+
+
+ 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 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
+
+
+
+ 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 a different one
+ The to move the labels from
+ The to move the labels to
+ The code instruction labels were moved from (now empty)
+
+
+ Moves all labels from a different code instruction to the current one
+ The to move the labels from
+ The to move the labels to
+ 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 a different one
+ The to move the ExceptionBlocks from
+ The to move the ExceptionBlocks to
+ The code instruction blocks were moved from (now empty)
+
+
+ Moves all ExceptionBlocks from a different code instruction to the current one
+ The to move the ExceptionBlocks from
+ The to move the ExceptionBlocks to
+ The code instruction that received the blocks
+
+
+ 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
+
+
+
+ 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.
+
+
+
+ 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
+
+
+
+
diff --git a/1.2/Assemblies/0MultiplayerAPI.dll b/1.2/Assemblies/0MultiplayerAPI.dll
new file mode 100644
index 0000000..f5d76b4
Binary files /dev/null and b/1.2/Assemblies/0MultiplayerAPI.dll differ
diff --git a/1.2/Assemblies/Rimefeller.dll b/1.2/Assemblies/Rimefeller.dll
new file mode 100644
index 0000000..f9f3d66
Binary files /dev/null and b/1.2/Assemblies/Rimefeller.dll differ
diff --git a/1.2/Defs/Designations/DesignationCategories.xml b/1.2/Defs/Designations/DesignationCategories.xml
new file mode 100644
index 0000000..0b76e50
--- /dev/null
+++ b/1.2/Defs/Designations/DesignationCategories.xml
@@ -0,0 +1,17 @@
+
+
+
+
+ Rimefeller
+
+ Things for oil and plastic production.
+ 10
+
+
Designator_Cancel
+
Designator_Deconstruct
+
Rimefeller.Designator_CleanOil
+
Rimefeller.Designator_RemovePipeline
+
+
+
+
\ No newline at end of file
diff --git a/1.2/Defs/Designations/Designations.xml b/1.2/Defs/Designations/Designations.xml
new file mode 100644
index 0000000..d74e15c
--- /dev/null
+++ b/1.2/Defs/Designations/Designations.xml
@@ -0,0 +1,10 @@
+
+
+
+
+ CleanOilDes
+ Rimefeller/UI/OilSpill
+ Cell
+
+
+
\ No newline at end of file
diff --git a/1.2/Defs/JobDefs/Jobs_Rimefeller.xml b/1.2/Defs/JobDefs/Jobs_Rimefeller.xml
new file mode 100644
index 0000000..d7e6beb
--- /dev/null
+++ b/1.2/Defs/JobDefs/Jobs_Rimefeller.xml
@@ -0,0 +1,37 @@
+
+
+
+ CleanOil
+ Rimefeller.JobDriver_CleanOil
+ clean oil.
+
+
+
+ SuperviseDrilling
+ Rimefeller.JobDriver_SuperviseDrilling
+ Supervising drilling operation.
+ true
+
+
+
+ EmptyAutoclave
+ Rimefeller.JobDriver_EmptyAutoclave
+ Emptying Autoclave.
+ true
+
+
+
+ FillAutoclave
+ Rimefeller.JobDriver_FillAutoclave
+ Filling Autoclave.
+ true
+
+
+
+ OperateResourceConsole
+ Rimefeller.JobDriver_OperateResourceConsole
+ operating TargetA.
+ true
+
+
+
\ No newline at end of file
diff --git a/1.2/Defs/ModOptions/ModOptions.xml b/1.2/Defs/ModOptions/ModOptions.xml
new file mode 100644
index 0000000..1ae5534
--- /dev/null
+++ b/1.2/Defs/ModOptions/ModOptions.xml
@@ -0,0 +1,196 @@
+
+
+
+
+ RimefellerExtensions
+
+
+
+ OilPipeVisibility
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ CrudeToFuelRatio
+
+
+
+
+
+ 0.1
+
+
+
+ 0.5
+
+
+
+ 1
+
+
+
+ 1.5
+
+
+
+ 2
+
+
+
+ 2.5
+
+
+
+ 3
+
+
+
+ 4
+
+
+
+ 5
+
+
+
+
+
+ OilPumpCapacity
+
+
+
+
+
+ 999
+
+
+
+ 2.5
+
+
+
+ 2
+
+
+
+ 1.5
+
+
+
+ 1
+
+
+
+ 0.75
+
+
+
+ 0.5
+
+
+
+ 0.25
+
+
+
+ 0.1
+
+
+
+
+
+ OilRegenRate
+
+
+
+
+
+ 50
+
+
+
+ 2.5
+
+
+
+ 2
+
+
+
+ 1.5
+
+
+
+ 1
+
+
+
+ 0.75
+
+
+
+ 0.5
+
+
+
+ 0.25
+
+
+
+ 0
+
+
+
+
+
+ OilGridCapacity
+
+
+
+
+
+ 500
+
+
+
+ 50
+
+
+
+ 25
+
+
+
+ 15
+
+
+
+ 10
+
+
+
+ 5
+
+
+
+ 1
+
+
+
+
+
\ No newline at end of file
diff --git a/1.2/Defs/RecipeDefs/Recipes_Production.xml b/1.2/Defs/RecipeDefs/Recipes_Production.xml
new file mode 100644
index 0000000..c7fbaec
--- /dev/null
+++ b/1.2/Defs/RecipeDefs/Recipes_Production.xml
@@ -0,0 +1,352 @@
+
+
+
+
+ Make_RefiningStub
+
+ bah
+
+
ResourceConsole
+
+
+
+
+ 1000
+
+
+
+
+
+
+
+
+
+
+ Make_Napalm
+
+ Make a batch of napalm by mixing chemfuel and synthylene. (Machining Table)
+ Mixing napalm.
+ Cremate
+ Recipe_Cremate
+ 2000
+ GeneralLaborSpeed
+
+
+
+
+
Synthylene
+
+
+ 25
+
+
+
+
+
Chemfuel
+
+
+ 50
+
+
+
+
+
Chemfuel
+
+
+
Synthylene
+
+
+
+ 50
+
+
+
TableMachining
+
+ Napalm
+
+
+
+ Make_ComponentIndustrialPlastic
+
+ Make a component.
+ Making component.
+ GeneralLaborSpeed
+ Cook
+ Recipe_Machining
+ 5000
+ UnfinishedComponent
+
+
+
+ 6
+ 0
+
+
+
+
+ ChemfuelRefining
+
+ Rimefeller
+ Refine crude oil into chemfuel to be stored in chemfuel tanks.
+ 1500
+ Industrial
+
+
OilDrilling
+
+ 1
+ 1
+
+
+
+ NeutroamineProduction
+
+ Rimefeller
+ Produce Neutroamine from stored chemfuel, used for making medicine
+ 4500
+ Industrial
+
+
SynthamideProduction
+
MedicineProduction
+
+ 5
+ 3
+
+
+
+ SynthyleneProduction
+
+ Rimefeller
+ Produce the generic building material synthylene with a selection of colours from stored chemfuel
+ 1500
+ Industrial
+
+
ChemfuelRefining
+
+ 2
+ 2
+
+
+
+ Napalm
+
+ Rimefeller
+ Highly flammable sticky jelly used in incendiary bombs, consisting of chemfuel thickened with synthylene
+ 500
+ Industrial
+
+
+
+ 3
+ 2
+
+
+
+ SynthamideProduction
+
+ Rimefeller
+ Produce Synthamide, Synthamide fibers are heat-resistant and strong synthetic fibers, they can be used for creating very durable clothing.
+ 3000
+ Industrial
+
+
SynthreadProduction
+
Fabrication
+
+ 4
+ 2
+
+
+
+ SynthamideCompositeProduction
+
+ Rimefeller
+ Produce Synthamide Composite, a high strength light weight fire resistant spacer tech composite material, made of a synthylene matrix reinforced with synthamide fibres
+ Synthamide Composite
+ You can now produce Synthamide composite! first craft uncured composite at a fabrication bench, construct an autoclave, then load uncured composite into the autoclave to cure it.
+ 4000
+ Industrial
+
+
SynthamideProduction
+
+ 5
+ 2
+
+
+
+ PlasteelProduction
+
+ Rimefeller
+ Discover the secrets of making Plasteel
+ Plasteel Production
+ You can now produce Plasteel! craft uncured Plasteel at a fabrication bench, construct an autoclave, then set the autoclave to plasteel curing mode.
+ 3500
+ Spacer
+
+
SynthamideCompositeProduction
+
+ 6
+ 2
+
+
+
+ HyperweaveProduction
+
+ Rimefeller
+ Discover the secrets of making Hyperweave
+ 3500
+ Spacer
+
+
PlasteelProduction
+
+ 7
+ 2
+
+
+
diff --git a/1.2/Defs/ResearchProjectDefs/ResearchProjects_Rimefeller_CE_FSX.xml b/1.2/Defs/ResearchProjectDefs/ResearchProjects_Rimefeller_CE_FSX.xml
new file mode 100644
index 0000000..96ece8a
--- /dev/null
+++ b/1.2/Defs/ResearchProjectDefs/ResearchProjects_Rimefeller_CE_FSX.xml
@@ -0,0 +1,18 @@
+
+
+
+
+ CE_FsxProduction
+
+ Rimefeller
+ Produce FSX from stored chemfuel, used for making explosives and specialty ammunition.
+ 1500
+ Industrial
+
+
+
+
+
+
\ No newline at end of file
diff --git a/1.2/Defs/Storyteller/Incidents_Map_Misc.xml b/1.2/Defs/Storyteller/Incidents_Map_Misc.xml
new file mode 100644
index 0000000..108345d
--- /dev/null
+++ b/1.2/Defs/Storyteller/Incidents_Map_Misc.xml
@@ -0,0 +1,51 @@
+
+
+
+
+ OilSpill
+
+ Misc
+
+
Map_PlayerHome
+
+ Rimefeller.IncidentWorker_OilSpill
+ Oil Spill
+ A section of pipeline has broken and Oil has spilled out, Oil can be cleaned using the clean oil designator.
+ ThreatSmall
+ 0.3
+ 30
+
+
+
+
+ DrillQuake
+
+ Misc
+
+
Map_PlayerHome
+
+ Rimefeller.IncidentWorker_Earthquake
+ Tremors
+ Excessive oil drilling has caused ground instability.
+ ThreatSmall
+ 0.3
+ 30
+
+
+
+
+
\ No newline at end of file
diff --git a/1.2/Defs/ThingCategoryDefs/ThingCategories.xml b/1.2/Defs/ThingCategoryDefs/ThingCategories.xml
new file mode 100644
index 0000000..25ca560
--- /dev/null
+++ b/1.2/Defs/ThingCategoryDefs/ThingCategories.xml
@@ -0,0 +1,21 @@
+
+
+
+
+ Oil
+
+ Root
+ Rimefeller/Things/Resource/OilBarrel
+
+
+
+ Plastic
+
+
+
+
+ Composite
+
+
+
+
\ No newline at end of file
diff --git a/1.2/Defs/ThingDefs_Buildings/BuildingsA_Pipes.xml b/1.2/Defs/ThingDefs_Buildings/BuildingsA_Pipes.xml
new file mode 100644
index 0000000..846648d
--- /dev/null
+++ b/1.2/Defs/ThingDefs_Buildings/BuildingsA_Pipes.xml
@@ -0,0 +1,292 @@
+
+
+
+
+
+ Rimefeller.Building_Pipe
+
+ Rimefeller/Things/Building/oilPipe_Atlas
+ Graphic_Single
+ Basic
+
+
+
+
+ false
+
+ 10
+
+
+
+
+
+
+
+
+ SynthyleneRefiner
+
+ Processes chemfuel into synthylene with a selection of colours, synthylene can be used as a generic building material and as an ingredient for components.
+
+ Rimefeller/Things/Building/SynthyleneRefinery
+ Graphic_Single
+ (4,4)
+
+
+ 150
+ 3
+
+
+
+
+ 10
+
+
+
+
\ No newline at end of file
diff --git a/1.2/Defs/ThingDefs_Buildings/BuildingsB_Refining_CE_FSX.xml b/1.2/Defs/ThingDefs_Buildings/BuildingsB_Refining_CE_FSX.xml
new file mode 100644
index 0000000..ae59970
--- /dev/null
+++ b/1.2/Defs/ThingDefs_Buildings/BuildingsB_Refining_CE_FSX.xml
@@ -0,0 +1,35 @@
+
+
+
+
+ CombatExtendedFsxRefiner
+
+ Processes chemfuel into FSX, a high-explosive chemical used in a variety of industrial and military applications.
+
+ Rimefeller/Things/Building/CeFsxRefinery
+ Graphic_Single
+ (4,4)
+
+
+ 150
+ 3
+
+
+