Screenshots

Testimonials

This tool allows you to easily build different “versions” of your game on multiple platforms.
We’re going to rapidly describe the different parts of the tool on this page. You can launch the interface by going to “Window/PygmyMonkey/Advanced Builder” in Unity.

Here you will define the global parameters for your product.
Currently you can only specify the bundle version, but more will be added in future releases.
Thanks to AdvancedBuilder, you can access the bundle version of your product during gameplay using AppParameters.Get.bundleVersion (something you can’t do with the current Unity API).

Let’s say your game have a Free and a Paid version (or Demo and Full).
Before, you would have to change the bundle identifier, product name and more before each build, and, if you needed to know which version you were on during runtime, you would have to set (and update) a boolean somewhere in your code to store this information.
Now, you can just add two release types, define the bundle identifier and product name for each, click on build and you will have two executables for your product. Then, during runtime, you can retrieve the release type using AppParameters.Get.releaseType or use default defines such as #RT_RELEASE.

In this section, you can add all the platforms your product supports, and also select some per-platform parameters such as:

Distribution Platforms

This is very useful if you want to publish your product to different sub-platforms:

• For Android, you may want to deliver your product through Google Play, but also the Amazon Appstore and maybe the Samsung AppStore. Well, you just have to add these 3 distribution platforms and Advanced Builder will automatically build 3 different builds for each of these sub-platforms.
  This is handy if you want to support In-App purchase for example, because for that, you need to call the IAP process from Google Play if users downloaded from the Google Play, and same thing for the Amazon Store. As there is no way of determining if a user downloaded your product through Google Play or Amazon Store, you can simply use 2 different APKs, and using the variable AppParameters.Get.distributionPlatform, you can call the IAP method from the correct platform.
• For the Web, you may want to have different builds, for your own website and for Kongregate.
• Same thing for Windows, maybe you want a version that you will sell on your website, and another that you will sell on Steam (and do different things in the code with it).

Textures Compression

(used by Android and BlackBerry)
If you use Generic, it will build using the default texture compression.
Let’s take Android for example. If you want, you can use different textures compression that will generate multiple APKs, that you will upload to Google. The Play Store will then automatically deliver the correct APK depending on the device downloading your product. With this, users will have an optimised version with texture compressions adapted to their device

Architectures

Using this you can simultaneously build for :

• Windows x86 and/or Windows x64
• OSX x86, OSX x64 and/or OSX Universal
• Linux x86, Linux x64 and/or Linux Universal
• Android x86, ARMv7 and/or FAT (ARMv7 + x86)
• iOS
• tvOS
• WebGL
• Windows Store

Build folder path

Here you can define the destination of your builds. By default it will be placed in /Builds/BUILD_DATE/RELEASE_TYPE/PLATFORM/DISTRIB_PLATFORM/ARCHITECTURE/, some examples:

• /Builds/13-12-16 10h23/Dev/iOS/MyProduct/
• /Builds/13-12-16 10h23/Dev/Android/Google Play/MyProduct – Generic.apk
• /Builds/13-12-16 10h23/Dev/Android/Amazon App Store/MyProduct – Generic.apk
• /Builds/13-12-16 10h23/Beta/Windows/Windows x86/MyProduct.exe

You can personalize the build destination by modifying the build folder path and using, or not, the different parameters at your disposal:

• $BUILD_DATE
• $RELEASE_TYPE
• $PLATFORM
• $DISTRIB_PLATFORM
• $ARCHITECTURE
• $TEXT_COMPRESSION
• $PRODUCT_NAME
• $BUNDLE_VERSION
• $BUNDLE_IDENTIFIER

Custom settings

Custom Build script

You can create a custom script that allow you to do actions before and after each build.
This script needs to implement the interface IAdvancedCustomBuild and be placed in an Editor folder.
You will have to implement the 6 methods OnEveryBuildStart, OnPreBuild, OnPostBuild,
OnEveryBuildDone, OnPreApplyConfiguration and OnPostApplyConfiguration.
Most methods have different parameters that will tell you information on the build that is currently processing, allowing you to do different things based on the platform, the release type, the distribution platform, the platform architecture and the texture compression.
You can find examples of custom build scripts in “Example/Editor/”.

Global custom defines

You can specify custom scripting define symbols that will be used in your project. For example, you could use DEBUG and PRINT_ERRORS defines by filling the global custom define field with DEBUG;PRINT_ERRORS
With that, in your code, you could use precompiled conditions such as #if DEBUG etc…

Build options

Let AdvancedBuilder overwrite scenes

When you toggle this, each configuration will override the EditorBuildsSettings scenes.

Let AdvancedBuilder overwrite defines

When applying a configuration, you can chose not to overwrite the current custom defines.

This section will list all the configurations available based on what you used in Release Types, and Platforms sections. You then add the ones you want so they can be used with the batch build.

You can then click on each configuration to see the different information associated with it.
You’ll see :
– a field so you can specify the name of the configuration if you need it (optional)
– a list of default defines that are automatically created based on the release type you created,
the platform, the platform architecture and the texture compression of the configuration
– a field where you can specify your custom defines associated with this configuration, so for each and every build, you can have a specific custom define. More information can be found in the Unity documentation.
– a list of scenes you want to build for this configuration
– You’ll also see all the information associated with this configuration
– You can also directly build this particular configuration, pressing the Build button
– And finally, the “Apply this config” button, that is very useful if you want to test a
configuration of your game directly in the Editor. It will apply all the parameters specified in
this configuration directly in Unity.
Please note that we do not switch platform when you select a configuration, but only update the AppParameters data and scripting define symbols associated with the configuration. So everything in your code relying on AppParameters and define symbols will work, but using Unity own scripting define symbols as #if UNITY_ANDROID will work only if you switch platform yourself. Using “Apply
this config”, you’ll be able to test everything in your code using the parameters in AppParameters and custom define symbols so you can test how your game will react on different configurations without the need to switch platform.

Using Unity Free:
You can use this window to manually select the configuration you want to use before manually building each version of your game. So you’ll have to click on the ‘Apply this config’ button to set the configuration you want, and then build manually every configuration. At the end of each build, you just select another configuration and build manually again etc…
Please, keep in mind that pressing ‘Apply this configuration’ will apply all the configuration parameters to your current project, but will NOT switch platform. So obviously, when you manually build with Unity, don’t forget to select your platform before pressing the Build button.

In this section, you can batch build all of the configurations you previously selected, in a single click. Make sure to check the ‘Warnings & Errors’ section to see if everything is ok…

This section will tell you if something is wrong. So pay attention before building!

If you are upgrading from a version older than 1.4.0, please follow these small steps

1. Save the file “AdvancedBuilder/Editor/AdvancedBuilder.asset” somewhere,
2. Close the AdvancedBuilder window,
3. Remove entirely the AdvancedBuilder folder,
4. Import the new version of AdvancedBuilder,
5. Put back the file you saved, inside the folder “PygmyMonkey/AdvancedBuilder/Editor”,
6. Open the AdvancedBuilder window and you’re good to go 🙂

Normal Procedure

1. Close the Advanced Builder window
2. Delete everything under the ‘AdvancedBuilder’ folder from the Project View, EXCEPT the file “/AdvancedBuilder/Editor/AdvancedBuilder.asset”
3. Import the latest version from the Asset Store

Unity batch mode allows you to launch Unity via a command line instruction and perform builds without having Unity opened. It allows you to perform automated builds on a production computer for example, building your app every x hours after performing a version control update etc…

You can read the documentation right here: http://docs.unity3d.com/Manual/CommandLineArguments.html
Then, you just need to open Unity once, configure Advanced Builder however you want, and use the following syntax with the command line:

PATH_TO_UNITY_INSTALLATION/Unity -quit -batchmode -projectPath “PATH_TO_YOUR_PROJECT” -executeMethod PygmyMonkey.AdvancedBuilder.AdvancedBuilder.PerformBuild​

It will do exactly the same thing than pressing the “Perform a total of x builds” button.

If you don’t want to have a folder called PygmyMonkey at the root of your project. You can easily move the PygmyMonkey folder (containing the AdvancedBuilder folder) to wherever you want in your project (of course, as long as it’s in the Assets/ folder…).

Let’s say you have a game that you want to release for Android, iOS and OSX Universal. And you want to have:
– a dev version, so you can test your game without erasing the release version on a device (because of the same package name)
– a beta version, that you will send to some people
– a release version, that will be released to the public

You just need to add all the configurations in the ‘Project Configurations’ section and when your game is ready, just click on the “Perform a total of 9 builds” button.

That’s it!

BONUS
At runtime, you can then use if (AppParameters.Get.releaseType.Equals(“Dev”)) to only call some debug methods, or send some stats to your webserver.
You could (and should) also use precompiled symbols such as #if RT_DEV.

Don’t forget you can use the custom build script, to do really anything before and/or after each build.

Now let’s say you’re making a game for iOS only and you want a Demo and Full version.

You just need to add all the configurations in the ‘Project Configurations’ section and when your game is ready, just click on the “Perform a total of 2 builds” button.

That’s it!

BONUS
At runtime, you can then use if (AppParameters.Get.releaseType.Equals(“Full”)) to allow users to access different parts of your game.
You could (and should) also use precompiled symbols such as #if RT_DEV.

If you’re using a custom build script, you could also, before each build, change/remove some GameObjects from a scene, or anything you want in the OnPreBuild method if the release type is Demo.

You can create a custom script that allow you to do actions before and after each build.
This script needs to implement the interface IAdvancedCustomBuild and be placed in an Editor folder.
You will have to implement the 6 methods OnEveryBuildStart, OnPreBuild, OnPostBuild,
OnEveryBuildDone, OnPreApplyConfiguration and OnPostApplyConfiguration.
Most methods have different parameters that will tell you information on the build that is currently processing, allowing you to do different things based on the platform, the release type, the distribution platform, the platform architecture and the texture compression.
You can find examples of custom build scripts in “Example/Editor/”.

WARNING If you’re using this method, this means your Android password is stored in clear text inside this file!
This file will not be part of the final binary (build) because this file is inside an Editor folder, BUT it will be available to anyone working with your source code, and will be commited to your versioning file system (if you use one).
So if you don’t want your password to be seen by others having access to this file. Do not use it 🙂

// Callback method that is called before each build
public void OnPreBuild(Configuration configuration, DateTime buildDate)
{
    if (configuration.platform.getPlatformProperties().platformType.Equals(PlatformType.Android))	
    {
        // Here is the keystore file that you normaly select via the file browser using the "Browse Keystore" button in PlayerSettings
        // If you have the keystore file inside this Unity project, simply set: "Assets/MyFolder/MyKeystore.keystore"
        // If the keystore file is outside this Unity project, you have to specify the full path, example:	
        // Mac: "/Users/xxx/Projects/Assets/Other/mykeystore.keystore"
        // Windows: @"C:\Projects\Assets\Other\mykeystore.keystore"
        PlayerSettings.Android.keystoreName = "FULL_PATH_TO_KEYSTORE_FILE";

        // Your Android keystore file password
        PlayerSettings.Android.keystorePass = "KEYSTORE_PASSWORD";

        // The name of the alias in the keystore file
        PlayerSettings.Android.keyaliasName = "KEY_ALIAS_NAME";

        // The password for the alias
        PlayerSettings.Android.keyaliasPass = "KEY_ALIAS_PASSWORD";
        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();
    }
}

// Callback method that is called after each build
public void OnPostBuild(Configuration configuration, DateTime buildDate)
{
    if (configuration.platform.getPlatformProperties().platformType.Equals(PlatformType.Android))
    {
        PlayerSettings.Android.keystoreName = null;
        PlayerSettings.Android.keystorePass = null;
        PlayerSettings.Android.keyaliasName = null;
        PlayerSettings.Android.keyaliasPass = null;
        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();
    }
}

public void OnEveryBuildDone()
{
}

Using the OnPre/OnPostBuild methods, you can use the sample code below, and adapt it to your needs.

The PlayerSettings.SetIconsForTargetGroup API takes the BuildTargetGroup and an array of texture2D of all the icon sizes.
The thing is, you have to specify the exact texture array size for each BuildTargetGroup, and the size is not the same for Android or iOS for example…

So what you can do, is first get the sizes for a platform using PlayerSettings.GetIconSizesForTargetGroup(targetGroup); once you have all that, you put your icons in a folder, with the name MY_ICON_XX where XX is the size.

private static void AssignPlayerSettingsIcons(BuildTargetGroup targetGroup)
{
    int[] iconSizeArray = PlayerSettings.GetIconSizesForTargetGroup(targetGroup);
    Texture2D[] iconArray = new Texture2D[iconSizeArray.Length];

    for (int i = 0; i < iconSizeArray.Length; i++)
    {
        Texture2D iconTexture = AssetDatabase.LoadAssetAtPath("YOUR_ICON_PATH/MY_ICON_" + iconSizeArray[i] + ".png", typeof(Texture2D)) as Texture2D;

        if (iconTexture != null)
        {
            iconArray[i] = iconTexture;
        }
        else
        {
            Debug.LogError("Error, could not find icon with size : " + iconSizeArray[i]);
        }
    }

    PlayerSettings.SetIconsForTargetGroup(targetGroup, iconArray);
}

• NEW Supported architectures for Android are now ARMv7 (32 bits), ARM64 (64 bits) or both,
• UPDATE Minimum Unity Editor version is now Unity 2018.1.

• NEW Added back the FAT architecture (ARMv7 + x86) for Android.

• NEW Now compatible with Unity 2018!,
• NEW Added settings to remove spaces from the build path.
• WARNING If you’re building for Android and are upgrading to Unity 2018.1, you will need to ‘reset’ the platform architectures to add support to the new ARMv64 architecture. Just click on the ‘Reset architectures” button under the Android platform section.

• NEW Added option to enable headless mode on Linux (in the configuration section),
• NEW Added two callbacks OnPreApplyConfiguration/OnPostApplyConfiguration that are trigger at the beginning and at the end of applying a configuration (at build time, or when you click on the ‘Apply this config’ button in the configuration section of the Advanced Builder window).

• NEW Minimum Unity version is now Unity 5.6
• NEW Added a custom build callback (OnEveryBuildStart) that is called at the beginning of the first build,
• NEW Now compatible with Unity 2017,
• NEW Remove every compatibility check with things < Unity 5.6 (Blackberry, WebGL…),
• UPDATE Windows x64 is now the default over x86,
• UPDATE Reactivated the ability to create an eclipse project for Android builds,
• FIX Fixed issue with setting custom scripting define symbols.

• NEW Added buildNumber to the Product Parameters section that will automatically increment with each build! You can access it at runtime if needed via AppParameters.Get.buildNumber
• UPDATE configuration.getBuildDestinationPath now takes productParameters as the last parameter, before that, it was productParameters.bundleVersion.
• FIX Fixed Unity 5.5 errors caused by obsolete BuildTargetGroups when building.

• FIX Advanced Builder window being laggy…

• FIX Fixed automatically finding the Advanced Builder folder on Windows.

• FIX Removed Windows Phone 8 support starting Unity 5.4 because Unity stopped supporting it.
  You’re supposed to use WSA instead.
• FIX Some warnings about Blackberry and WP8 on Unity 5.4

• NEW Improved the way we get the path to the advanced builder folder (it’s now automatic).
  (Note: So the previous Preferences window is now removed).

• NEW Added a preference window to change the path of the PygmyMonkey folder (see the “Moving the ‘PygmyMonkey/AdvancedBuilder’ folder” section in the documentation for more info).
• FIX Fixed some issues related to Unity 5.4 or newer.

• FIX Really fixed issues with Unity 5.4…

• FIX Fixed issues happening with Unity 5.4 (Removed Blackberry and WebPlayer platforms as Unity no longer support them)

• FIX Fixed issue that was happening when you added a release type.

• NEW Added OnEveryBuildDone() callback to the custom builds, which is a callback triggered when all the builds are done.
• NEW Added support for tvOS platform.

• NEW Added the ‘Let AdvancedBuilder overwrite defines’ option to Build options. When applying a configuration, you can now chose not to overwrite the current custom defines.

• NEW Now requires at least Unity 5.0.0
• NEW Bundle version can now use the format “xx.xx.xx.xx”, instead of just “xx.xx.xx”
• NEW ‘Append project’ is now available again for iOS. You can chose to append projects in each configuration.
• NEW You now open Advanced Builder via the menu “Window/PygmyMonkey/Advanced Builder”, it was previously in “Tools/PygmyMonkey/Advanced Builder”.
• NEW Added support for Windows Store
• NEW Added $BUNDLE_VERSION and $BUNDLE_IDENTIFIER to set your custom build destination path

• NEW Added buildDate to OnPreBuild/OnPostBuild events.
• UPDATE Moved some options (Open build folder after build, Dev build, Autoconnect profiler, Allow script debugging, Autorun) to configurations, so you can set them for each configuration.

• NEW You can now reorganize the scenes you selected for each configuration.
• NEW You can now decide if you want to let Advanced Builder decide which scenes are build in the ‘AdvancedSettings’ section.
• NEW You can now set a custom file name for your build (in addition to the build folder path).
• NEW Added $TEST_COMPRESSION and $PRODUCT_NAME constants for custom build folder path and custom file name.
• FIX Android bundle version code if you were using FAT/x86/ARMv7.

• WARNING IF YOU ARE UPGRADING FROM A VERSION OLDER THAN THIS ONE (1.4.0), PLEASE FOLLOW THE STEPS DESCRIBED IN “How to update Advanced Builder” at the bottom of the Get Started page.
• NEW You now open Advanced Builder via the menu “Tools/PygmyMonkey/Advanced Builder”, it was previously in “Windows/Advanced Builder”.
• NEW Changed all the namespaces from “com.pygmymonkey.tools” to “PygmyMonkey.AdvancedBuilder”.
• NEW Moved the entire “AdvancedBuilder” folder inside a “PygmyMonkey” folder.

• NEW Added platform architectures for Android. You can now automatically build for ARMv7, x86 (Intel) or FAT (ARMv7 and x86).

• NEW Added support for Unity5.
• NEW Added WebGL support.

• NEW You can now manage the scenes you want to build per configuration.

• NEW Added configurations. You now have a list of configurations defined by all the release types, platforms, platform architectures, distribution platforms and texture compression you selected. With each configuration, you can see all the build info, directly build a configuration and apply a configuration to the UnityEditor to test your configuration directly in the Editor without the need to build or switch platform.
• NEW Add support for custom compilation defines. Now you can define your custom defines for each configuration. There is also some default defines created by AdvancedBuilder based on the parameters of the configuration.

• NEW Added a custom build example showing you how you can chose different scenes depending on the release type you’re building.
• NEW Added a custom build example that will automatically set your Android keystore password.

• FIX Updated documentation
• NEW Improved the way ‘Project Configuration’ works, so you can easily try multiple configuration directly in the Unity Editor without switching platforms.
  This update will probably create some errors in your scripts if you were using the AppParameters class and/or custom build scripts.
  – To access data via AppParameters, you will now need to call “AppParameters.Get.DATA” where DATA is the data you want to retrieve (for example, to retrieve the release type, you would call: AppParameters.Get.releaseType).
  – For custom build scripts, the OnPreBuild/OnPostBuild methods now take strings instead of enums as parameters.

• FIX Fix setting configurations using Unity Free

• NEW In the Advanced Settings section, you can now chose to display an error when you forgot to set your Android Keystore and Alias passwords.
• FIX Display errors when incorrect name format are set for Distribution Platform and Release Types

• NEW Added support for Distribution Platforms! (see Get Started for more info)

• FIX Building for Mac on a Windows machine was disabled by mistake (it’s now possible again)

• NEW Added a ‘Project Configuration’ window. You can now apply different configuration directly in the Editor to test your game on each of these configurations. This is also useful for people using Unity Free. (see Get Started & FAQ for more info).
• NEW You can now activate/deactivate platforms you want to support (instead of deleting them)
• NEW Added warning message if you try to build for iOS on Windows or Linux
• NEW Added error message if using the same name in different release types
• FIX Scenes not enabled in the build settings will not be build anymore
• FIX Custom build methods now use the enums in AppParameters.cs instead of classes

• FIX Fixed BlackBerry build issue (Unity bug if you have a space in the .bar file name)
• FIX Fixed InvalidOperationException thrown by Unity Editor GUI after a build operation
• FIX Fixed iOS build if you had the Facebook Unity plugin in your project

• NEW Added support for Windows Phone 8
• NEW Added support for Windows Store 8
• NEW Added support for BlackBery

• FIX Display warning and errors even when platforms or release types are not fold out
• FIX Build date on the build folder was incorrect if the total builds took more than 1 minute

• Initial release.