File Structure

The AoA unlocker mod file

{
  "_meta": {
    "DisplayName": "AoA for All"
  },
  "FilePatches": {
    "ProjectWingman/Content/ProjectWingman/Blueprints/Data/AircraftData/DB_Aircraft.uexp": [{
      "name": "AoA Unlock",
      "patches": [{
        "description": "Set CanUseAoA",
        "template": "00 48 02",
        "substitution": "01"
      }]
    }]
  }
}

Now let’s step through each part of this file.

Patch Metadata (_meta)

The first thing you’ll usually find in a Sicario patch file is the _meta field, which is an object with a few optional properties:

• DisplayName: A user-friendly name to show for your mod
• Author: Take a guess what this one’s for hotshot
• Description: also self-explanatory

All three of these values will be shown to users so please don’t just put “do the thing” or fill them in with shitposting!

There is some more metadata you can optionally provide, but that’s covered later on.

The File Patches (FilePatches)

The FilePatches object is the main “substance” of a Sicario patch. It is a dictionary grouping the files to be edited with sets of patches to be applied to that file.

Note that to support auto-packing you need to include the game file as the full target path for the file you’re editing.

In the example above, we have just one key in the object: ProjectWingman/Content/ProjectWingman/Blueprints/Data/AircraftData/DB_Aircraft.uexp. This just means that DB_Aircraft.uexp will be the only file that this patch will be applied to and it will be packed in that specific path. Each file then has an array of “patch sets”.

Patch Sets

Patch Sets are a purely logical organizational idea: they’re just a way of organizing patches together. For example, if your mod is changing multiple stats for multiple planes, you might include each plane as a separate patch set. A patch set is just an object with name and an array of patches:

{
  "name": "AoA Unlock",
  "patches": []
}

On it’s own a patch set doesn’t do anything, that’s up to the actual patches in the set.

Patches

Now we hit the real meat of a Sicario patch: the actual hex edit to make. Here’s the example for enabling AoA for all aircraft:

{
  "description": "Set CanUseAoA",
  "template": "00 48 02",
  "substitution": "01",
  "type": "before"
}

In plain English, this object just tells Sicario “replace the byte immediately before 00 48 02 with a 01”.

Template and Substitution

These are the actual values Sicario will be (respectively) looking for and inserting into the binary file. When it runs, Project Sicario will load the file into memory, look for any appearance of the template value and then apply the substitution. How exactly the substitution is applied varies based on the patch type.

Types

The two main types of patches currently in use are:

• before: replaces the byte(s) before the template with the value of substitution.
• inPlace: replaces the entire template with the value of the substitution.

There is also a valueBefore type, but it’s only useful in niche scenarios

In fact, we could have also shown the AoA patch above with an inPlace patch:

{
  "description": "Set CanUseAoA",
  "template": "00 00 48 02",
  "substitution": "01 00 48 02",
  "type": "inPlace"
}

To translate, this patch just tells Sicario “replace every occurrence of the byte pattern 00 00 48 02 with the byte pattern 01 00 48 02”. These two examples serve essentially the same purpose, so choose the patch type that makes the most sense.

That being said, you should place a preference towards using inPlace: users will be shown a warning when including a before type patch since they ignore load order and could undo changes from another patch.