InjectFix Documentation

InjectFix is a hotfix solution for Unity business logic. It supports the full series of Unity versions and all platforms. Key features include:

• Direct C# Updates: You can update logic by directly modifying C# code within the Unity project.
• Non-intrusive Integration: Existing projects can use InjectFix without needing to modify original source code.
• Secure Patch Format: Each game uses its own private patch format, ensuring better security.

IFix operates using two distinct stages:

1. Inject: A one-time preprocessing step. This must be done when sending the package to users. It prepares the code so that it is capable of switching to patch logic at runtime.
2. Fix: The process of generating a patch. This is done after you have modified your code and want to create a .patch.bytes file to fix the logic in the field.

Recommended Editor Workflow: To avoid the limitation where IFix refuses to generate a patch if it thinks you are already on the 'online' version:

1. Modify code to the correct logic.
2. Run InjectFix/Fix to generate the patch.
3. Revert the code to the incorrect logic.
4. Run InjectFix/Inject to simulate the problematic online version.

The Inject process is a one-time operation (typically performed when building the package) that pre-processes the code. Only code that has been pre-processed via Inject can load patches at runtime.

Steps:

1. Revert your code to the 'problematic' (original) logic.
2. In the Unity Editor, execute the menu command: InjectFix/Inject.
3. To apply a patch at runtime, copy your generated patch file (e.g., Assembly-CSharp.patch.bytes) to Assets/IFix/Resources.

To enable hotfixing, you must first configure which classes should be preprocessed. This allows the preprocessed code to switch to the patch code at runtime.

Requirements:

1. The configuration class must be placed in an Editor directory.
2. The configuration class must be decorated with the [Configure] attribute.
3. The property decorated with [IFix] must be static and return an IEnumerable<Type>.

You can manually list types or use Reflection/LINQ to include entire namespaces.

[Configure]
public class HelloworldCfg
{
    [IFix]
    static IEnumerable<Type> hotfix
    {
        get
        {
            return new List<Type>()
            {
                typeof(IFix.Test.Calculator)
            };
        }
    }
}

To generate a patch for a specific function:

1. Open the source file (e.g., Calc.cs).
2. Apply the [Patch] attribute to the function you wish to fix.
3. In the Unity Editor, execute the menu command: InjectFix/Fix.
4. Upon success (process success), a file named Assembly-CSharp.patch.bytes will be created in your project root directory.

To make a function eligible for hotfixing, decorate it with the [Patch] attribute.

1. Add [Patch] to the target function:

[Patch]
public int Add(int a, int b)
{
    return a + b;
}

2. In the Unity Editor, execute the menu command: "InjectFix/Fix".
3. The generated patch file will be saved in your project directory with the naming convention {Dll Name}.patch.bytes (e.g., Assembly-CSharp.patch.bytes).
4. Upload this file to the target device and load it using PatchManager.Load.

To enable hotfixing for specific classes, you must define a configuration class. This configuration tells the InjectFix preprocessor which types are eligible to be switched to patch code at runtime.

Requirements:

1. The configuration class must be placed in an Editor directory.
2. The class must be decorated with the [Configure] attribute.
3. The configuration property must be decorated with the [IFix] attribute and must be declared as static.
4. The property must return an IEnumerable<Type>.

You can manually list types or use LINQ and Reflection to include entire namespaces automatically.

[Configure]
public class HelloworldCfg
{
    [IFix]
    static IEnumerable<Type> hotfix
    {
        get
        {
            return new List<Type>()
            {
                typeof(IFix.Test.Calculator)
            };
        }
    }
}