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/BadHygiene.dll b/1.2/Assemblies/BadHygiene.dll
new file mode 100644
index 0000000..70205dc
Binary files /dev/null and b/1.2/Assemblies/BadHygiene.dll differ
diff --git a/1.2/Defs/Designations/DesignationCategories.xml b/1.2/Defs/Designations/DesignationCategories.xml
new file mode 100644
index 0000000..85d6dfd
--- /dev/null
+++ b/1.2/Defs/Designations/DesignationCategories.xml
@@ -0,0 +1,16 @@
+
+
+
+ Hygiene
+
+ Things for colonists hygiene.
+ 10
+
+
Designator_Cancel
+
Designator_Deconstruct
+
DubsBadHygiene.Designator_RemoveSewage
+
DubsBadHygiene.Designator_RemovePlumbing
+
DubsBadHygiene.Designator_AreaPlaceFertilizer
+
+
+
\ 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..0c339b5
--- /dev/null
+++ b/1.2/Defs/Designations/Designations.xml
@@ -0,0 +1,22 @@
+
+
+
+
+ RemoveSewageDes
+ Designations/Haul
+ Cell
+
+
+
+ kickOverDes
+ DBH/UI/kickOver
+ Thing
+
+
+
+ drainOutDes
+ DBH/UI/drainOut
+ Thing
+
+
+
\ No newline at end of file
diff --git a/1.2/Defs/Effects/Effecter_Misc.xml b/1.2/Defs/Effects/Effecter_Misc.xml
new file mode 100644
index 0000000..66bdc8c
--- /dev/null
+++ b/1.2/Defs/Effects/Effecter_Misc.xml
@@ -0,0 +1,105 @@
+
+
+
+
+ Fecal
+
+
+
+
+
+
+ Dysentery
+
+ Dysentery is a type of gastroenteritis that results in diarrhea with blood
+ HediffWithComps
+ IllnessRevealed
+ true
+ 1
+ true
+
+
+ 48
+ -0.1105
+
+
+ 0.2488
+ 0.2614
+ -0.4947
+ -0.06
+
+
+
+
+
+
+ 0.5
+
+
+
+ Consciousness
+ -0.05
+
+
+ Manipulation
+ -0.05
+
+
+ Breathing
+ -0.1
+
+
+
+
+ 0.666
+
+ 1.5
+
+ 1
+
+
+
+ Consciousness
+ -0.1
+
+
+ Manipulation
+ -0.1
+
+
+ Breathing
+ -0.15
+
+
+
+
+ 0.833
+
+ true
+ 0.75
+ 0.05
+
+ 1.5
+
+
+
+ Consciousness
+ -0.15
+
+
+ Manipulation
+ -0.2
+
+
+ Breathing
+ -0.2
+
+
+
+
+
+
+
+ Cholera
+
+ Cholera is an infectious disease that causes severe watery diarrhea, which can lead to dehydration and even death if untreated
+ IllnessRevealed
+ true
+ 1
+ true
+
+
+ 12
+ -0.3628
+
+
+ 0.666
+ 0.5224
+ -0.333
+ -0.02
+
+
+
+
+
+ 0.2
+
+ 0.5
+
+
+
+ Consciousness
+ -0.05
+
+
+ Manipulation
+ -0.05
+
+
+
+
+ 0.6
+
+ 0.35
+
+ 1
+
+
+
+ Consciousness
+ -0.2
+
+
+ Manipulation
+ -0.2
+
+
+
+
+ 0.8
+
+ 0.6
+
+ 2
+
+
+
+ Consciousness
+ -0.3
+
+
+ Manipulation
+ -0.3
+
+
+
+
+ 0.9
+
+ true
+ 0.85
+
+ 3
+
+
+
+ Consciousness
+ -0.3
+
+
+ Manipulation
+ -0.3
+
+
+ Breathing
+ -0.15
+
+
+
+
+
+
+
+
+ DBHDehydration
+
+ Dehydration is a condition that can occur when the loss of body fluids, mostly water, exceeds the amount that is taken in
+ 1
+ true
+ false
+ false
+
+
+
+
+
+
\ 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..b487e94
--- /dev/null
+++ b/1.2/Defs/ModOptions/ModOptions.xml
@@ -0,0 +1,782 @@
+
+
+
+
+ DubsBadHygieneExtensions
+
+
+
+ PipeVisibility
+
+ false
+ 1
+ How should pipes be rendered
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ HygieneRateD
+
+ 10
+ How fast the hygiene need falls
+
+
+
+ 0
+
+
+
+ 0.1
+
+
+
+ 0.2
+
+
+
+ 0.3
+
+
+
+ 0.4
+
+
+
+ 0.5
+
+
+
+ 0.6
+
+
+
+ 0.7
+
+
+
+ 0.8
+
+
+
+ 0.9
+
+
+
+ 1
+
+
+
+ 1.1
+
+
+
+ 1.2
+
+
+
+ 1.3
+
+
+
+ 1.4
+
+
+
+ 1.5
+
+
+
+ 2
+
+
+
+ 3
+
+
+
+ 5
+
+
+
+ 10
+
+
+
+
+
+ BladderRateD
+
+ 10
+ How fast the bladder need falls
+
+
+
+ 0
+
+
+
+ 0.1
+
+
+
+ 0.2
+
+
+
+ 0.3
+
+
+
+ 0.4
+
+
+
+ 0.5
+
+
+
+ 0.6
+
+
+
+ 0.7
+
+
+
+ 0.8
+
+
+
+ 0.9
+
+
+
+ 1
+
+
+
+ 1.1
+
+
+
+ 1.2
+
+
+
+ 1.3
+
+
+
+ 1.4
+
+
+
+ 1.5
+
+
+
+ 2
+
+
+
+ 3
+
+
+
+ 5
+
+
+
+ 10
+
+
+
+
+
+ FlushSize
+
+ 3
+ How much sewage is produced from each flush
+
+
+
+ 0
+
+
+
+ 0.25
+
+
+
+ 0.5
+
+
+
+ 1
+
+
+
+ 1.5
+
+
+
+ 2
+
+
+
+ 2.5
+
+
+
+
+
+ ThirstRateD
+
+ true
+ 10
+ How fast the thirst need falls
+
+
+
+ 0
+
+
+
+ 0.1
+
+
+
+ 0.2
+
+
+
+ 0.3
+
+
+
+ 0.4
+
+
+
+ 0.5
+
+
+
+ 0.6
+
+
+
+ 0.7
+
+
+
+ 0.8
+
+
+
+ 0.9
+
+
+
+ 1
+
+
+
+ 1.1
+
+
+
+ 1.2
+
+
+
+ 1.3
+
+
+
+ 1.4
+
+
+
+ 1.5
+
+
+
+ 2
+
+
+
+ 3
+
+
+
+ 5
+
+
+
+ 10
+
+
+
+
+
+ ContaminationChance
+
+ 4
+ Multiply the chance for a colonist getting contaminated from untreated water
+
+
+
+ 0.00001
+
+
+
+ 0.1
+
+
+
+ 0.25
+
+
+
+ 0.5
+
+
+
+ 1
+
+
+
+ 1.25
+
+
+
+ 1.5
+
+
+
+ 1.75
+
+
+
+ 2
+
+
+
+
+
+ WaterPumpCapacity
+
+ 3
+ Multiply the capacity of water pumps
+
+
+
+ 999
+
+
+
+ 0.4
+
+
+
+ 0.3
+
+
+
+ 0.2
+
+
+
+ 0.15
+
+
+
+ 0.1
+
+
+
+ 0.05
+
+
+
+
+
+ WaterHeatingRate
+
+ 3
+ Multiply how much hot water is used while washing
+
+
+
+ 0.1
+
+
+
+ 1.5
+
+
+
+ 0.75
+
+
+
+ 1
+
+
+
+ 1.25
+
+
+
+ 1.5
+
+
+
+ 2
+
+
+
+
+
+ SewageGridCapacity
+
+ 3
+ Set the limit for how much sewage can fit into a cell on the surface
+
+
+
+ 1000
+
+
+
+ 100
+
+
+
+ 50
+
+
+
+ 25
+
+
+
+ 20
+
+
+
+ 15
+
+
+
+ 5
+
+
+
+
+
+ SewageCleanupRateB
+
+ 5
+ How fast sewage on the surface cleans up over time
+
+
+
+ 10
+
+
+
+ 3
+
+
+
+ 2
+
+
+
+ 1.5
+
+
+
+ 1.25
+
+
+
+ 1
+
+
+
+ 0.75
+
+
+
+ 0.5
+
+
+
+ 0.25
+
+
+
+ 0.1
+
+
+
+ 0
+
+
+
+
+
+ SewageProcRate
+
+ 4
+ Multiply how fast sewage is treated in septic tanks and sewage treatment
+
+
+
+ 100
+
+
+
+ 2
+
+
+
+ 1.5
+
+
+
+ 1.25
+
+
+
+ 1
+
+
+
+ 0.75
+
+
+
+ 0.5
+
+
+
+ 0.25
+
+
+
+ 0.1
+
+
+
+
+
+ IrrigationGridStrength
+
+ 4
+ Multiply the effect of irrigation on fertility
+
+
+
+ 10
+
+
+
+ 2.4
+
+
+
+ 2.2
+
+
+
+ 2
+
+
+
+ 1.8
+
+
+
+ 1.6
+
+
+
+ 1.4
+
+
+
+ 1.2
+
+
+
+ 1.1
+
+
+
+
+
+ FertilizerGridStrength
+
+ 4
+ Multiply the effect of fertilizer on fertility
+
+
+
+ 10
+
+
+
+ 1.6
+
+
+
+ 1.4
+
+
+
+ 1.2
+
+
+
+ 1.1
+
+
+
+ 1.08
+
+
+
+ 1.06
+
+
+
+ 1.04
+
+
+
+ 1.02
+
+
+
+
+
+ TerrainFertilityFactor
+
+ 5
+ Set the base value of terrain fertility
+
+
+
+ 10
+
+
+
+ 1.8
+
+
+
+ 1.4
+
+
+
+ 1.2
+
+
+
+ 1.1
+
+
+
+ 1
+
+
+
+ 0.9
+
+
+
+ 0.8
+
+
+
+ 0.6
+
+
+
+ 0.4
+
+
+
+ 0.2
+
+
+
+
+
+ FertilizerLifespan
+
+ 5
+ How long until fertilized terrain expires
+
+
+
+ 9999
+
+
+
+ 240
+
+
+
+ 180
+
+
+
+ 120
+
+
+
+ 80
+
+
+
+ 60
+
+
+
+ 40
+
+
+
+ 30
+
+
+
+ 20
+
+
+
+ 10
+
+
+
+ 1
+
+
+
+
+
\ No newline at end of file
diff --git a/1.2/Defs/NeedDefs/Needs_Misc.xml b/1.2/Defs/NeedDefs/Needs_Misc.xml
new file mode 100644
index 0000000..ecc22b3
--- /dev/null
+++ b/1.2/Defs/NeedDefs/Needs_Misc.xml
@@ -0,0 +1,77 @@
+
+
+
+
+ Bladder
+ DubsBadHygiene.Need_Bladder
+
+ To prevent the risk of disease it is important to maintain a good level of sanitation by removing or treating waste, and preventing sewage from contaminating you water supply.
+ true
+ 0.8
+ 401
+
+
+
HumanoidTerminator
+
AIRobot
+
AIPawn
+
+
+
+
+
ROMV_Fangs
+
+
+
+
+
+
+
+ Hygiene
+ DubsBadHygiene.Need_Hygiene
+
+ Good personal hygiene is important for reducing the risk of disease and keeping colonists happy and healthy.
+ true
+ Humanlike
+ 0.8
+ 321
+
+
+
HumanoidTerminator
+
AIRobot
+
AIPawn
+
+
+
+
+
+
+
+
+
+
+
+
+ DBHThirst
+ DubsBadHygiene.Need_Thirst
+
+ Water is required for many of life’s physiological processes. If this reaches zero then the creature will slowly die of dehydration
+ true
+ Humanlike
+ 0.8
+ 402
+ true
+
+
+
HumanoidTerminator
+
AIRobot
+
AIPawn
+
+
+
+
+
ROMV_Fangs
+
+
+
+
+
\ No newline at end of file
diff --git a/1.2/Defs/PollutionTypes/PollutionTypes.xml b/1.2/Defs/PollutionTypes/PollutionTypes.xml
new file mode 100644
index 0000000..5ee84f7
--- /dev/null
+++ b/1.2/Defs/PollutionTypes/PollutionTypes.xml
@@ -0,0 +1,44 @@
+
+
+
+
+ PollutionTypes
+
+
+
+
+
+ Filth_OilSlick
+ 30
+
+
+ FilthAsh
+ 2
+
+
+ FilthCorpseBile
+ 3
+
+
+ BurnPit
+ 15
+
+
+ Grave
+ 20
+
+
+ DeepDrill
+ 30
+
+
+ CrashedPoisonShipPart
+ 50
+
+
+
+
+
\ 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..997e835
--- /dev/null
+++ b/1.2/Defs/RecipeDefs/Recipes_Production.xml
@@ -0,0 +1,36 @@
+
+
+
+
+ Make_ChemfuelFromFecalSludge
+
+ Make a batch of chemfuel from Fecal Sludge.
+ Refining chemfuel from Fecal Sludge.
+ Cremate
+ Recipe_Cremate
+ 3000
+ GeneralLaborSpeed
+
+
+
+
+
FecalSludge
+
+
+ 75
+
+
+
+
+
FecalSludge
+
+
+
+ 10
+
+
+
BiofuelRefinery
+
+
+
+
diff --git a/1.2/Defs/ResearchProjectDefs/ResearchProjects_Hygiene.xml b/1.2/Defs/ResearchProjectDefs/ResearchProjects_Hygiene.xml
new file mode 100644
index 0000000..a9fd24f
--- /dev/null
+++ b/1.2/Defs/ResearchProjectDefs/ResearchProjects_Hygiene.xml
@@ -0,0 +1,319 @@
+
+
+
+
+
+ DubsBadHygiene
+
+
+
+
+
+ SewageSludgeComposting
+
+ DubsBadHygiene
+ When properly treated and processed, sewage sludge becomes biosolids that offer a small boost to terrain fertility, useful for harsh environments with limited space to grow. Biosolids also produce a large boost to the fertility of sand which can make it fertile when combined with irrigation.
+ 800
+ Medieval
+ 0
+ 1
+
+
+
+ MultiSplitAirCon
+
+ DubsBadHygiene
+ Build multi-split air conditioning systems with outdoor units piped to indoor units and freezers.
+ 700
+ Industrial
+
+
AirConditioning
+
+ 3
+ 0
+
+
+
+
+ Plumbing
+
+ DubsBadHygiene
+ Use pipes, plumbing fixtures, storage tanks, windwells and other apparatuses to deliver and drain water and sewage.
+ 400
+ Medieval
+
+
ClassicStart
+
+ 0
+ 2
+
+
+
+
+
+
+ LogBoilers
+
+ DubsBadHygiene
+ Build log boilers which can be used to heat rooms and placed adjacent to baths to heat bathwater.
+ 400
+ Medieval
+
+
ClassicStart
+
+ 0
+ 0
+
+
+
+ CentralHeating
+
+ DubsBadHygiene
+ Build central heating systems with radiators, hot water tanks, boilers and thermostats.
+ 400
+ Industrial
+
+
+
+ 2
+ 2
+
+
+
+ ElectricPumps
+
+ DubsBadHygiene
+ Powered water pumps for pressurised continuous water pumping.
+ 500
+ Industrial
+
+
ClassicStart
+
+
+
ModernFixtures
+
Electricity
+
+ 3
+ 2
+
+
+
+
+
+
+
+
+ AdvancedShowers
+
+ DubsBadHygiene
+ Build powered showers which halves the time spent showering and improves comfort.
+ 800
+ Industrial
+
+
ElectricPumps
+
+ 5
+ 0.5
+
+
+
+ AdvancedToilets
+
+ DubsBadHygiene
+ Build smart toilets which are twice as water efficient as a standard toilets and provide more comfort.
+ 1500
+ Industrial
+
+
ElectricPumps
+
+ 5
+ 1
+
+
+
+ HotTubs
+
+ DubsBadHygiene
+ Build hot tubs which can be used for hydrotherapy, relaxation and pleasure.
+ 2000
+ Industrial
+
+
+
+ 6
+ 2
+
+
+
+ DeepWells
+
+ DubsBadHygiene
+ Drill deeper wells to access a much larger area of ground water.
+ 2000
+ Industrial
+
+
ElectricPumps
+
+ 5
+ 2.5
+
+
+
+ WashingMachines
+
+ DubsBadHygiene
+ Build washing machines that can wash clothes so well that you couldn't even tell someone died wearing it!.
+ 1200
+ Industrial
+
+
ElectricPumps
+
+ 5
+ 3
+
+
+
+ WaterFiltration
+
+ DubsBadHygiene
+ Build water filtration systems which treats the water supply eliminating the risk of disease.
+ 1500
+ Industrial
+
+
ElectricPumps
+
+ 5
+ 3.5
+
+
+
+
+
+
+ SepticTanks
+
+ DubsBadHygiene
+ Build septic tanks which accumulate sewage and provide moderate treatment of sewage.
+ 500
+ Medieval
+
+
Plumbing
+
+ 2
+ 1
+
+
+
+ SewageTreatment
+
+ DubsBadHygiene
+ Build large sewage treatment systems which accumulate large amounts of sewage and provides fast treatment of sewage.
+ 2000
+ Industrial
+
+
+
+
+
+
\ No newline at end of file
diff --git a/1.2/Defs/Stats/Stats_Pawns_General.xml b/1.2/Defs/Stats/Stats_Pawns_General.xml
new file mode 100644
index 0000000..d261c78
--- /dev/null
+++ b/1.2/Defs/Stats/Stats_Pawns_General.xml
@@ -0,0 +1,46 @@
+
+
+
+
+ ThirstRateMultiplier
+
+ A multiplier on how quickly a creature becomes thirsty.
+ BasicsPawn
+ 1.0
+ PercentZero
+ false
+ 1
+ 0
+ 75
+ true
+
+
+
+ HygieneRateMultiplier
+
+ A multiplier on how quickly a creatures hygiene level falls.
+ BasicsPawn
+ 1.0
+ PercentZero
+ false
+ 1
+ 0
+ 2500
+ true
+
+
+
+ BladderRateMultiplier
+
+ A multiplier on how quickly a creatures bladder level falls.
+ BasicsPawn
+ 1.0
+ PercentZero
+ false
+ 1
+ 0
+ 2500
+ true
+
+
+
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..e666b69
--- /dev/null
+++ b/1.2/Defs/Storyteller/Incidents_Map_Misc.xml
@@ -0,0 +1,35 @@
+
+
+
+
+ TowerContamination
+
+ Misc
+
+
Map_PlayerHome
+
+ DubsBadHygiene.IncidentWorker_TowerContamination
+ Contaminated Water Tower
+ A water tower has become polluted, this poses a serious risk to the health of your colonists! Drain the tower to clear the contamination, or build a water treatment system.
+ ThreatSmall
+ 0.3
+ 15
+ 2
+
+
+
+
\ 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..5975ac6
--- /dev/null
+++ b/1.2/Defs/ThingCategoryDefs/ThingCategories.xml
@@ -0,0 +1,17 @@
+
+
+
+
+ Waste
+
+ Root
+ DBH/Things/Resource/BurnBarrel
+
+
+
+ BuildingsHygiene
+
+ Buildings
+
+
+
\ 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..5cd324c
--- /dev/null
+++ b/1.2/Defs/ThingDefs_Buildings/BuildingsA_Pipes.xml
@@ -0,0 +1,158 @@
+
+
+
+
+
+
+ DubsBadHygiene.Building_Pipe
+
+ DBH/Things/Building/SewagePipe_Atlas
+ Graphic_Single
+ Basic
+
+
+
+
+
+
+
+
+ PitLatrine
+
+ A pit latrine that collects feces in a hole in the ground. Must be emptied manually, can be plumbed.
+ DubsBadHygiene.Building_Latrine
+
+ DBH/Things/Building/Latrine
+ Graphic_Multi
+
+ (0.2,0.2,0.6,0.6)
+
+
+ Building
+ PassThroughOnly
+
+ 75
+ 800
+ 2.0
+ -5
+ -5
+ 5
+
+ true
+ 0.15
+
+
Metallic
+
Woody
+
Stony
+
+ 15
+ true
+ 8
+ true
+
+
DubsBadHygiene.PlaceWorker_SewageGrid
+
+
+
+
+ PrimitiveWell
+
+ Accesses ground water, water must be hauled to a water tub before it can be used for washing or drinking.
+
+ DBH/Things/Building/Water/PrimitiveWell
+ Graphic_Single
+ (2,2)
+ false
+
+ Normal
+ Building
+ Building
+ PassThroughOnly
+ false
+ false
+ 60
+ true
+
+
Metallic
+
Woody
+
Stony
+
+ 25
+ 7.9
+
+
DubsBadHygiene.PlaceWorker_WaterGrid
+
DubsBadHygiene.PlaceWorker_SewageGrid
+
+
+
+ DubsBadHygiene.CompBaseWell
+
+
+ true
+ false
+
+ 100
+ 2000
+ 1.0
+
+ true
+
+
+
+ WashBucket
+
+ Tub of water used for personal hygiene, must be regularly refilled with fresh water. Can also be used for drinking if thirst is enabled.
+ DubsBadHygiene.Building_washbucket
+
+ DBH/Things/Building/filthyBucket
+ Graphic_Single
+ CutoutComplex
+
+ (0.2,0.2,0.6,0.6)
+
+
+ MinifiedThing
+
+
+
+
+
+
+ BurnPit
+
+ Eliminates fecal sludge by burning it as fuel. Can also be used for disposing of corpses or other detritus. Colonists may become sick if they spend too long near burning waste.
+ DubsBadHygiene.Building_BurnPit
+ Building
+
+ DBH/Things/Building/Sewage/burnPit
+ Graphic_Single
+ false
+ false
+
+ (0.2,0,0.6,0.1)
+
+
+ Building
+ PassThroughOnly
+ 50
+ ConstructDirt
+ Normal
+ RealtimeOnly
+ 0.20
+
+ 80
+ 200
+ 0
+
+ true
+
+ 20
+
+ BulletImpact_Ground
+ false
+ 0
+
+
+
+
+
+
+
+
+ Sanitation fixture used for the disposal of human urine and feces.
+ DubsBadHygiene.Building_toilet
+
+ DBH/Things/Building/Toilets/toilet
+ Graphic_Multi
+ CutoutComplex
+
+ (0.2,0.2,0.6,0.6)
+
+ (2,2)
+
+ Building
+ PassThroughOnly
+
+ 75
+ 950
+ 1.0
+ 1
+ 0.1
+ 18
+
+ 0.15
+ true
+ 8
+ true
+
+ true
+
+
+
ModernFixtures
+
+
+
+
+ ToiletStuff
+
+
+
Metallic
+
Woody
+
Stony
+
+
+ 5
+
+ 15
+
+
+
+ ToiletAdv
+ DubsBadHygiene.Building_AdvToilet
+ Twice as water efficient as a standard toilet. Provides the optimum multi-functional experience with automatic cleansing and deodorization.
+
+ DBH/Things/Building/Toilets/toilet
+ Graphic_Multi
+
+
+ 1950
+ 4
+ 0.5
+
+
+
+ CompPowerTrader
+ 75
+
+
+
+
+
AdvancedToilets
+
+
+
+
+
+ ToiletAdvStuff
+
+
+ 1
+
+
+
Metallic
+
Woody
+
Stony
+
+ 35
+
+
+
+
+
+ Slow to use and requires large amounts of water, but very comfortable. Can be heated by placing an adjacent campfire or log boiler, or via plumbed hot water tanks. Does not require a sewage outlet.
+ DubsBadHygiene.Building_bath
+
+ (2,3)
+ DBH/Things/Building/Baths/bath
+ Graphic_Multi
+ CutoutComplex
+
+ Building
+
+ 75
+ 1300
+ 1.0
+ 10
+ 0.9
+ 0.7
+ 50
+
+ 0.15
+ (1, 2)
+ PassThroughOnly
+ true
+ 8
+ true
+
+
Plumbing
+
+ Normal
+
+
+
+
Campfire
+
LogBoiler
+
+
+
+
+
+
+
+ BathtubStuff
+
+
+
Metallic
+
Woody
+
Stony
+
+
+ 5
+
+ 30
+
+
+
+
+
+ Simple shower. Requires water from water towers. Can be heated via plumbed hot water tanks. Does not require a sewage outlet.
+ DubsBadHygiene.Building_Shower
+
+ (2,2)
+ DBH/Things/Building/Showers/shower
+ Graphic_Multi
+ CutoutComplex
+
+ Building
+
+ 75
+ 1300
+ 1.0
+ 3
+ 0.5
+ 20
+
+
+ 0.15
+ PassThroughOnly
+ true
+ 8
+ true
+
+
ModernFixtures
+
+
+
+
+
+ ShowerStuff
+
+
+ 1300
+
+
+ 5
+
+
+
Metallic
+
Woody
+
Stony
+
+ 20
+
+
+
+ ShowerSimple
+
+
+ (2,2)
+ DBH/Things/Building/Showers/showerSimple
+ Graphic_Multi
+ CutoutComplex
+
+
+ 800
+
+
+ 15
+
+
+
+
+
+ ShowerAdvStuff
+
+ Features a large 110mm 4 spray powered showerhead to relax those aching muscles. Heats water on demand and doubles washing speed!
+ DubsBadHygiene.Building_PowerShower
+
+ (2,2)
+ DBH/Things/Building/Showers/showerAdv
+ Graphic_Multi
+ CutoutComplex
+
+
+ 8
+ 0.8
+ 3000
+
+
+
+ CompPowerTrader
+ 75
+
+
+
+
+ 1
+ 10
+
+
+
Metallic
+
Woody
+
Stony
+
+ 20
+
+
AdvancedShowers
+
+
+
+
diff --git a/1.2/Defs/ThingDefs_Buildings/BuildingsC_Joy.xml b/1.2/Defs/ThingDefs_Buildings/BuildingsC_Joy.xml
new file mode 100644
index 0000000..78c8173
--- /dev/null
+++ b/1.2/Defs/ThingDefs_Buildings/BuildingsC_Joy.xml
@@ -0,0 +1,289 @@
+
+
+
+
+
+
+
+
+
+ PoolWater
+
+ 395
+ 0
+ Hard
+
+ 0
+ 18
+ 0
+ true
+
+
+
+ Swimming pool used for hydrotherapy, relaxation or pleasure. Must be filled with water from water towers first.
+ DubsBadHygiene.Building_FillableThing
+ DBHSwimmingPool
+
+
+
+
+ Normal
+ 5
+
+
+
+ Hot tub used for hydrotherapy, relaxation or pleasure. Filled with water from water towers on first use. Self heated and does not require a sewage outlet.
+ DubsBadHygiene.Building_HotTub
+ HotTub
+
+
+ 20
+ 4
+
+
+
+
+ Hygiene
+
+
+
+
+
+
diff --git a/1.2/Defs/ThingDefs_Buildings/BuildingsD_WaterManagement.xml b/1.2/Defs/ThingDefs_Buildings/BuildingsD_WaterManagement.xml
new file mode 100644
index 0000000..5a0f997
--- /dev/null
+++ b/1.2/Defs/ThingDefs_Buildings/BuildingsD_WaterManagement.xml
@@ -0,0 +1,617 @@
+
+
+
+
+
+
+
+
+ DBH/Things/Building/Water/WaterWell
+ Graphic_Single
+ (1,1)
+ false
+
+ Building
+ Normal
+ Building
+ PassThroughOnly
+ false
+ false
+ 60
+ true
+
+ 50
+
+ true
+ true
+
+ 100
+ 15000
+ 1.0
+
+
+
+
+
+
+
+
+ WaterWellInlet
+
+ Accesses ground water which can be pumped by water pumps. The presence of sewage or other pollution will reduce water quality and can cause contamination.
+ 7.9
+
+
Plumbing
+
+
+
+ Sewage
+
+
+
+
+
DubsBadHygiene.PlaceWorker_WaterGrid
+
DubsBadHygiene.PlaceWorker_SewageGrid
+
+
+
+
+ DeepWaterWellInlet
+
+ Accesses a large area of ground water which can be pumped by water pumps. Deep wells are unaffected by pollution.
+
+ DBH/Things/Building/Water/DeepWaterWell
+ Graphic_Single
+ (1,1)
+ false
+
+ 13.7
+
+ 29000
+
+
+ 100
+
+
+
DeepWells
+
+
+
+ Sewage
+
+
+ true
+
+
+
+
DubsBadHygiene.PlaceWorker_DeepWaterGrid
+
DubsBadHygiene.PlaceWorker_SewageGrid
+
+
+
+
+ Stores water for use by plumbed fixtures. If the contained water becomes contaminated, the tank must be drained.
+ Normal
+ true
+ false
+ false
+ 60
+
+ false
+
+ false
+
+ -15
+
+
+
+
+
+
+
+ PumpingStation
+
+ Pumps water from wells to water towers. Pumping capacity: 10000 L/day
+
+ DBH/Things/Building/Water/waterPumpingStation
+ Graphic_Single
+ false
+ (2,2)
+
+ Never
+ (2,2)
+
+ 120
+ 3
+
+
+ 150
+ 5000
+ 1.0
+
+
+
+ CompPowerTrader
+ 1000
+
+
+
+
+ 10000
+
+
+
+
LargeWaterPumps
+
+
+
+
+
+
+
+
+
+
+ SewageOutlet
+
+ Can be placed anywhere. Sewage will pool and spread on land or disperse in water. Sewage cleans up over time; the presence of trees, water or rain will speed this up.
+
+ DBH/Things/Building/Sewage/sewagePipe
+ Graphic_Multi
+ (3,3)
+
+ (0.05,0.05,0.95,0.95)
+
+
+ (1,1)
+ Building
+ Normal
+ RealtimeOnly
+ Building
+ PassThroughOnly
+ false
+ false
+ 60
+ DBH/UI/outlet
+ true
+
+
+
+
+
+
+
+
+
+ SewageSepticTank
+
+ Slowly cleans sewage over time. Sewage is directed to septic tanks first. If it reaches full capacity then excess sewage is sent to sewage outlets.
+
+ DBH/Things/Building/Sewage/SepticTank
+ Graphic_Single
+ (2,2)
+
+ Building
+ Normal
+ false
+ Building
+ Standable
+ false
+ false
+ 0
+ (2,2)
+
+
+
+
+
+
diff --git a/1.2/Defs/ThingDefs_Buildings/BuildingsF_Irrigation.xml b/1.2/Defs/ThingDefs_Buildings/BuildingsF_Irrigation.xml
new file mode 100644
index 0000000..abc60f0
--- /dev/null
+++ b/1.2/Defs/ThingDefs_Buildings/BuildingsF_Irrigation.xml
@@ -0,0 +1,234 @@
+
+
+
+
+
+
+ IrrigationSprinkler
+
+ Waters the surrounding area once every morning to improve the fertility of the soil through the day. Requires large amounts of water from water towers while spraying
+
+ DBH/Things/Building/sprinkler
+ Graphic_Single
+
+ (0.25, 0.5, 0.25)
+ (0,0,-0.1)
+
+
+ (0.2,0.2,0.6,0.6)
+
+
+ MinifiedThing
+
+
+
+ true
+ 1
+ None
+
+ 100
+ -40
+ -25
+ 0.2
+ 1.0
+ 2
+
+ 5
+
+
+
+ Biosolids
+
+ When properly treated and processed, sewage sludge becomes biosolids that offer a small boost to terrain fertility, useful for harsh environments with limited space to grow. Biosolids also produce a large boost to the fertility of sand which can make it fertile when combined with irrigation.
+
+ DBH/Things/Resource/bagSoil
+ Graphic_Single
+
+
+ 100
+ 0.1
+ 5.0
+ 0.05
+
+
+
Waste
+
+ 250
+ false
+ true
+
+
+
+ FecalSludge
+
+ A barrel filled with fecal sludge, can be dumped, burned, or composted into biosolids.
+
+ DBH/Things/Resource/BurnBarrel
+ Graphic_Single
+
+
+ 100
+ 1.0
+ 0.05
+ -100
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/About/About.xml b/About/About.xml
index 3f9db9d..2c8bf45 100644
--- a/About/About.xml
+++ b/About/About.xml
@@ -7,6 +7,7 @@
1.0
1.1
+
1.2
Dubwise.DubsBadHygieneAdds a sewage system, toilets, bathing, hygiene related needs and mood effects, central heating, water, irrigation, fertilizer, air conditioning, hot tubs, kitchen sinks, you name it!.