Big secret sale - [Released] AiUnity products (Build scripts, Multiple tags, and Logging)

Introducing AiUnity asset store products (All 5 stars):

Secret price cut on all AiUnity products (10% to 33% OFF):
Every AiUnity product rating has been five stars. Please rate to build the community.

All product have a powerful Editor GUI to eliminate coding if desired.

The AiUnity asset store products can really help the common developer:
ScriptBuilder - Automatically generate any script (i.e. Type safe Tag or AnimatorController access script).
NLog Logger - A powerful logger that can control log level per class, adjust content, and compile out log statements.
MultipleTags - Multiple tags on gameObjects using only the existing Unity tag system.
CLog Logger - A flexible logger that enables you to dynamically choose a custom or included logger for each platform.

ScriptBuilder: It is literally like having another programmer on your team.
NLog/CLog: Logging should be a developers biggest ally.
MultipleTags: Discover how tagging should really work.

Forum threads for each product:
ScriptBuilder forum thread
MultipleTags forum thread
NLog forum thread
CLog forum thread




ScriptBuilder (Highlights):.....................................................................MultipleTags (Highlights):
-Solely utilizes the existing Unity tag system...................................-Solely utilizes the existing Unity tag system.
-Intuitive find APIs that handle multiple tags...................................-Intuitive find APIs that handle multiple tags.
-Auto create type safe tag access script.............................................-Auto create type safe tag access script.
-Advanced GUI shows and modifies tags..........................................-Advanced GUI shows and modifies tags.

NLog Logger (Highlights):.......................................................................CLog Logger (Highlights):
-Control log levels by class or namespace.........................................-Customize log format and content.
-Customize log format and content............................................................-Debug in editor or inside game.
-Debug in editor, remotely, or inside game...........................................-Create and swap out your own logger.
-APIs for 5 log levels with helpful overloads.....................................-APIs for 5 log levels with helpful overloads.
-Compile out logs by level for performance.......................................-Compile out logs by level for performance.

AiUnity products trailer:

Thanks,
aidesigner

 

ScriptBuilder overview:
ScriptBuilder automatically generates C# scripts based upon a supplied or custom builder script. Make a custom builder that creates multiple ideal starting scripts or use it to generate a commonly used complex script. Alternatively use an existing builder like AnimatorBuilder (Tutorial), which probes the internal Unity Animator system to generate an Animator access script. This generated script will provide strongly typed access to your animator controller layers, states, parameters, and hash Ids using corresponding names (i.e. IsIdleState(), SetSpeed(), and UpperBodyLayer.CurrentStateName()).

TagAccessBuilder creates a script that provides type safe access to the Unity Tags, and is compatible with AiUnity MultipleTags (Enables multiple tags on a gameObject). The SkeletonBuilder creates a basic starting script and is easily altered to add boiler plate code like a custom logger (i.e. AiUnity logger NLog). Other supplied builders include ExampleBuilder, SceneAccessBuilder and LayerAccessBuilder.

Every facet of ScriptBuilder can be configured via the intuitive and comprehensive Unity editor GUI. The GUI tracks all generated scripts so they can be updated or overwritten via the Editor GUI or file context menu. In addition a builder can be set to automatically regenerate its script whenever an update is available (i.e. Animator changes). A configurable template exists to give you control of how the members of your generated script are formatted and organized. Custom builders can also be shared using the Share Builders forum.

Any C# file you create in a deterministic way is an opportunity to allow ScriptBuilder to take over.

Features:
-Script generation/management is handled by a comprehensive Unity Editor GUI.
-Included Animator Builder creates an indispensable animator access file.
-Included Skeleton Builder Builder creates a starting point for a custom builder.
-Included Skeleton Script Builder yields an alternative starting C# script.
-Intuitive APIs to build custom builders.
-Comprehensive API reference manual.
-Public builder variables are adjustable from ScriptBuilder GUI.
-Regenerate existing script from GUI or project view context menu.
-Builders can automatically regenerate a script whenever update is available.
-Regenerated scripts can update or overwrite previous script.
-Use GUI preview button to view potential updates to a previously generated script.
-The GUI provides a revert button to undo the last script update.
-GUI themed for light and dark skin.
-Create custom template to control format and order of class members.
-Alternative region template inserts #region sections into generated class.
-Timeless asset in that script creation will always be part of Unity.
-Works with AiUnity products MultipleTags, NLog, and CLog.
-Website/forum available for support.
-Forum category provided to share builders.
-Tested on .NET 3.5 and 4.6.
-Full source code provided.

 

Forgive my English ((I wanted to write that it's hard for me to choose what I want from your creations all too delicious))

 

I would like to receive everything)) but I do not like to receive without cash. There will be cash I will buy everything at once.

 

ScriptBuilder looks like it might be very useful.

 

NLog Logger Overview:
NLog asset store product is a comprehensive Unity logging framework based upon the extremely popular open source project .NET NLog project. From the provided editor GUI you have dynamically control of logging levels, platforms, targets, content, and format. With NLog you can route your logging statements based upon class, namespace, or custom name to various targets. The available targets include Unity Console, In-Game Console, Remote Log Viewer, Log File, Email, or create your own. The In-Game Console allows you to debug inside your game while the Remote Log Viewer will have you debugging remotely in minutes.

Each target has a layout property that controls message content and format. Select from the dropdown variable list to inject content like logging level, calling method, and timestamp into log messages. Alternatively use Unity Rich Text formatting to color code messages from a particular class or namespace. The logging level of each logger can also be controlled, allowing you to increase logging verbosity of the namespace(s) under development.

With NLog you can improve performance by compiling out your logging statements on unselected platforms or logging levels. A log tester is built into to the GUI to help you verify and tweak your configurations. The available logging levels are Trace, Debug, Info, Warning, Error, Fatal, and Assert. NLog extensibility makes it easy to create new targets and layout variables. Automatically instantiate NLog in new scripts using the AiUnity flagship product ScriptBuilder (Automatically generate any Unity script).

Features:
-Complete logging control with a comprehensive NLog Editor GUI.
-Extended log levels are Trace, Debug, Info, Warning, Error, Fatal, and Assert.
-Logging API overloads accept formatted arguments to eliminate string.format().
-Control what messaging level is enable for each platform independently.
-Compile out logging statements on unselected platforms and levels.
-Create rules to direct log messages to various targets on a class, namespace, or platform basis.
-Use target properties to customize message content and destination features.
-The Remote Log Viewer target can send log messages over UDP to a remote viewer.
-The ugui base In-Game console target enables gameplay debug.
-Target wrappers enables advanced features like multiple targets.
-Add message content by using custom text or selectable internal variables.
-Format messages with Unity Rich Text.
-Use the comprehensive GUI to configure NLog or the underlying XML.
-Verify configuration with build in tester.
-Drop down menus give you quick access to targets and content variables.
-GUI themed for light and dark skin.
-Retain the ability to navigate to Source code and GameObject with double clicks.
-Dynamically switch between NLog source code and DLLs.
-Extend NLog with custom targets, wrappers and layout variables.
-Timeless asset in that logging will always be a fundamental debug tool.
-Works with AiUnity products ScriptBuilder, CLog, and MultipleTags.
-Dedicated website and forum available.
-Tested on .NET 3.5 and 4.6.

 

MultipleTags Overview:
MultipleTags enables you to apply multiple tags to a GameObject, solely using the existing Unity tag system. This is done by stitching tags together to form a tagPath (i.e. T1/T2/T3). By delineating tags with backslashes the Unity tag system will present a tagPath in a concise hierarchical menu structure. To augment the Unity tag interface an extremely powerful and elegant tag manager editor GUI is provided. The tag manager makes it easy to add/remove tags, find gameObjects by tag, optimize tags, generate a type safe tag access file, and much more (See screenshots). The tag manager also displays the tags associated with the currently selected gameObject(s). MulitpleTags also provides the ability to use tag groups to facilitate organization and discovery (i.e. Color.Red).

At runtime an intuitive set of APIs are available to harness the power of having multiple tags. FindGameObjectsWithTags API exists to find gameObjects with specfied tag(s), while gameObject extension methods allow you to refine your search. The extension methods also allow you to add/remove tags at runtime (Tags must exist in Unity). When searching for gameObjects a boolean enumeration is available or for greater flexibility use a free-form expression (i.e. (Tag1 | Tag2) & !Tag3). The search expression also supports regex syntax (i.e. Tag.*). To help form and test a search expression use the dropdown menu in the GUI "Find tags" section.

MultipleTags can manually or automatically generate a type safe tag access script (i.e. TagAccess.cs). This enables type safety, code completion, and boosts performance of the tag search APIs. Also related is the AiUnity flagship ScriptBuilder product, which uses builders to generate any Unity script. It includes the builder TagBuilder, if you wish to gain direct control of the Tag Access script generation.

Features:
-Completely utilizes Unity tag system.
-The Unity tag manager is augmented by a comprehensive tag GUI control panel.
-Select GameObject(s) in hierarchy to reveal and modify tags in GUI.
-Search/modify Unity tags from GUI.
-Search/modify gameObject tags from GUI.
-Use tag access script to reference Unity tags in a type safe manner.
-APIs available to find gameObjects using tag name, logic expression, or Regex.
-APIs can find gameObjects using group tag syntax (i.e. Vehicle.Car).
-APIs can find all gameObjects in a particular group (i.e. Vehicle).
-GameObject extension methods enable search refinement and tag modification.
-Automatic or manual creation of a type safe tag access script (TagAccess.cs).
-GUI optimize command allows quick cleanup/optimization of existing tags.
-GUI themed for light and dark skin.
-Works with AiUnity products ScriptBuilder, NLog, and CLog.
-Website, API Reference, Videos, and forums available for support.
-Tested on .NET 3.5 and 4.6.
-Full source code provided.

 

CLog Logger Overview:
CLog is a flexible Unity logging framework based upon the highly popular open source project .NET Common Logging. CLog provides a powerful and generic wrapper around an included or custom logger, allowing loggers to be freely exchanged. Available loggers include Unity Console, In-Game Console, and the powerful NLog Logger (Separate product). The In-Game Console allows you to debug from inside your game while the Unity Console will enhance your familiar debugging experience. From the GUI, loggers can be configured to inject information such as associated class, calling method, timestamp, log level, and exception message.

CLog can be configured to have a different logger for each platform. You could configure CLog to use UnityConsole in editor, the In-Game Console on XBox, and exclude logging for mobile devices. Every facet of CLog can be configured via the intuitive and comprehensive Unity Editor GUI. The configuration is stored an XML, which completely separates the GUI from CLog runtime.

CLog can improve performance by compiling out your logging statements on unselected platforms or logging levels. A log tester is built into to the GUI to help you verify and tweak your configurations. The available logging levels are Trace, Debug, Info, Warning, Error, Fatal, and Assert. CLog extensibility make it easy to create new targets. Automatically instantiate NLog in new scripts using the AiUnity flagship product ScriptBuilder (Automatically generate any Unity script).s

Features:
-Total control over logging during development through a comprehensive Unity Editor GUI.
-Log message levels are Trace, Debug, Info, Warning, Error, Fatal, and Assert.
-Log message API overloads allow format arguments to eliminating the need to use string.<br/>format().
-Control what messaging level is enable for each platform independently.
-Ability to assign a different logger for each platform.
-Logging statements on unselected platforms/levels are compiled out of existence.
-Adapters provided for loggers UnityConsole logger, In-Game logger, Null logger, and NLog Logger.
-Ideal for Asset or Library projects because it is lightweight, dynamic configurable, and freely distributed.
-Configure CLog via the Unity Editor GUI which includes edit access to the underlying XML.
-A log tester is built into to the GUI so you can verify the configurations.
-Retain the ability to double click log messages to take you to GameObject and source code line.
-GUI themed for light and dark skin.
-Easily extend CLog by adding custom targets for your log messages.
-Highly extendible with full source code provided.
-Dynamically switch between using CLog source code or DLLs.
-Timeless asset in that logging will always be a fundamental debug tool.
-Works with AiUnity products ScriptBuilder, NLog, and MultipleTags.
-Dedicated website and forum available for support issues.
-Tested on .NET 3.5 and 4.6.
-Full source code provided

 

CLog feature spotlight: Create a custom or included logger for each platform:

CLog comes with a UnityConsole logger, an in game GameConsole logger, and the ability to create your own logger. It might be desirable to use the UnityConsole logger in the Editor, the GameConsole on mobile devices, and no logger for game consoles. This not only makes loggers useful on multiple platforms, but can boost performance. In addition CLog has an adapter that allows you to use the powerful NLog Logger.

NLog feature spotlight: Control log levels by class, namespace, or logger name:

This means you can turn up the debug level on just the namespaces or classes under development. As a project grows the logs inevitably get cluttered as you begin to see your life scroll bye in the debug console. By listening to the class under development you can again pay attention to your logs, while you configure other classes to report errors and warnings.

ScriptBuilder feature spotlight: Create type safe access scripts:

One place automatically generated scripts shine, is in the creation of type safe access scripts. Some examples of this are scripts to access your tags, layers, scenes, and animator controllers. The type safe access script allows you to reference items like MyTags.Vehicle, MyScenes.Main, or MyAnimator.IsWalkState. This makes the code readable, easy to change, shows problem with compile errors, and allows code completion.

This tremendous ability is only a taste of what Script Builder can do for you.

MulitpleTags feature spotlight: Multiple tags utilizes the existing Unity tag system:

This means you do not have to add components to your gameObjects or add a gameObject to your hierarchy. This is accomplished by stitching multiple tags together with a backslash, which becomes a tag in the Unity tag system.
By delineating tags with backslashes the Unity tag system will present a tag path in a concise hierarchical menu structure. To augment the Unity tag interface an extremely powerful and elegant tag manager editor GUI is provided.

 

AiUnity products feature spotlight: An insane level of documentation, tutorials, and support is available.

At the moment there exists detailed screenshots, illustrated video tutorials, dedicated forums, chat service, dedicated website, API references, FAQ webpage, Unity forum thread, quick starts, editor tooltips/links, and PDF manuals. In addition I test all AiUnity products for at least 6 months before release.

 

Excellent products and outstanding workflow for logging in Unity. These plugins make you love Unity once again .

The only problem I have faced so far was in changing values in editor GUI. When you input a new value or choose something from a dropdown, it seems that the new value is not taken until you click on something in the Hierarchy or Project window (so basically changing the mouse focus). Even pressing enter after inputting a value does not seem to work. I am using Unity 5.3.6.

 

Thank you for the kind words. I really believe these assets are like having more people on your team.

Some of the products purposely use OnLostFocus()/OnFocus() to perform updates as you figured out. In the case of NLog the configuration (editor values) is always stored in file NLog.xml, which allows the editor and runtime components to be completely disconnected. Using Focus events was done to minimize file writes and to wait for all user changes before changing the configuration. I will take a look at this for the next release as reacting to the enter key sounds like a good idea.

 

ScriptBuilder video tutorial playlist:

 

MultipleTags video tutorial playlist:

 

NLog Logger video tutorial playlist:

 

CLog Logger video tutorial playlist:

 

ScriptBuilder feature spotlight: Run builder from project view context menu:

In addition to automatically generating/maintaining a script from the Script Builder GUI, the same can be done from the project view context menu. This is analogous to the existing Unity "Create -> C# Script", but now you have the freedom to build any script. This is ideal for making multiple starting scripts of varying complexity. Like any builder it can harness the Unity editor APIs to derive a script that is tailored to a given project content.

 

NLog feature spotlight: Compile out log statements by platform or log level:

Logging statements at a specific log level(s) (i.e. Debug, Trace, or All) can degrade performance and be unwanted on certain platforms. Based on the user configuration in the NLog GUI, preprocessor defines are set to indicate the log levels enabled on a given platform. NLog contains C# conditional attribute on all the logging API method calls. The end result is that unwanted logging statements are literally and completely compiled out of the appropriate builds. This can be adjusted at any point by changing a single setting in the NLog GUI.

 

MulitpleTags feature spotlight: Powerful and intuitive find APIs that handle multiple tags:

At runtime an intuitive set of APIs are available to harness the power of having multiple tags. FindGameObjectsWithTags API exists to find gameObjects with specified tag(s), while gameObject extension methods allow you to refine your search. The extension methods also allow you to add/remove tags at runtime (Tags must exist in Unity). To help form and test a search expression use the drop-down menu in the GUI "Find tags" section.

APIs can find GameObjects based upon multiple/type safe tag(s)

Code (CSharp):

1. // Find gameObjects with tag "T1".
2. GameObject[] gameObjects = TagService.FindGameObjectsWithTags("T1");
3. // Find gameObjects with tags "T1" or "T3" in a type safe manner.
4. gameObjects = TagService.FindGameObjectsWithTags(TagLogic.Or, TagAccessExample.T1, TagAccessExample.T3);
5. // Find gameObjects with tags "T1" or "T3", and is Color.Red.
6. gameObjects = TagService.FindGameObjectsWithTags("(T1 | T3) & Color.Red");
7. // Use regex pattern to find gameObjects with tags starting with "T"
8. gameObjects = TagService.FindGameObjectsWithTags("T.*");
9. // Use extension method to refine search to require tag "T3"
10. gameObjects = gameObjects.FindGameObjectsWithTags(TagLogic.And, TagAccessExample.T3);

 

CLog feature spotlight: Compile out log statements by platform or log level:

Logging statements at a specific log level(s) (i.e. Debug, Trace, or All) can degrade performance and be unwanted on certain platforms. Based on the user configuration in the CLog GUI, preprocessor defines are set to indicate the log levels enabled on a given platform. CLog contains C# conditional attribute on all the logging API method calls. The end result is that unwanted logging statements are literally and completely compiled out of the appropriate builds. This can be adjusted at any point by changing a single setting in the CLog GUI.

 

ScriptBuilder screenshot: Demonstrates updating the type safe access script build with AnimatorBuilder:

 

ScriptBuilder screenshot: Example type safe access script build with AnimatorBuilder:

 

ScriptBuilder screenshot: Creating a custom builder using the intuitive APIs:

 

MultipleTags screenshot: Shows multiple tags with the Unity GUI or advanced MultipleTags GUI:

 

Use MultipleTags GUI to find a manipulate multiple tags of a gameObject:

 

Use MultipleTags APIs to search for gameObjects with multiple tags:

 

NLog screenshot: Shows NLog GUI along with example console messages from Test Logger:

 

NLog screenshot: Demonstrates the ability to choose logging target(s) or create a custom target:

 

NLog screenshot: Using NLog in code:

 

NLog screenshot: NLog GameConsole target:

 

NLog screenshot: NLog RemoteViewer target:

 

CLog screenshot: Shows CLog GUI along with example console messages from the Test Logger:

 

CLog screenshot: Demonstrates the ability to choose logging target(s) or create a custom target:

 

CLog screenshot: Using CLog in code:

 

CLog screenshot: CLog GameConsole target:

 

The AiUnity asset store products that can really help the common developer:

ScriptBuilder - Automatically generate any script (i.e. Type safe Tag or AnimatorController access script).
NLog Logger - A powerful logger that can control log level per class, adjust content, and compile out log statements.
MultipleTags - Multiple tags on gameObjects using only the existing Unity tag system.
CLog Logger - A flexible logger that enables you to dynamically choose a custom or included logger for each platform.

 

Secret price cut again on AiUnity products (Up to 40% off):

 

Every AiUnity product rating has been five stars.

 

All AiUnity products tested on Unity 2018.1 and 2018.2.

 

Secret price cut just became available on AiUnity products (15% to 33% OFF)

 

You can now find a live interview, where I discuss all AiUnity products with Messy Coder.