Heathen Engineering is nearing release of the new Heathen Systems framework.
Heathen Systems is a tollbox of common use tools and componenets for the Unity 3D game engine and is the result of 4 years of continious development and learning with Unity. As of January 2018 Heathen Engineering is in the process of migrating all existing Unity Assets published by Heathen Engineering to the Heathen System Framework. This process will greatly enhance the quality, efficency and functionality of Heathen's Unity Asset offerings.
Heathen's UIX Keyboard is the first assets to be migrated and with Unity now for review and approval.
Heathen Systems Core
All Heathen assets will be built from the Heathen Systems Core. Core is a light weight collection of Scriptable Objects, Components, Interfces, Abstracts, Base Classes, Inspectors and Property Drawers. Core's objective is to improve the workflow between designers and engineers with a consistent, modular and Unity styled approch.
Heathen Systems Core decreases dependency on singltons (but doesn't exclude there use) and decreases the complexity of collaborative work helping to modularize your projects data model and systems events. Here are a few of the features of Systems Core; Core will be freely published on the Unity Assets soon and will be included with all Heathen Assets going forward.
Serializable variants of common Unity types which saddly aren't nativly serializable such as Vector, Transform, Quaternion and Color.
Standard Scriptable Objects
Scriptable Object representations of primative data types and common Unity types such as string, float, bool, Vector2 and more. These standard objects are refered to as Scriptable Variables.
Scriptable Variable References
References allow developers to use them in place of the corasponding data type.
public float PlayerHealth;
public FloatReference PlayerHealth;
This allows the designer to decide in editor if they will use a constant value as would be the case of a normal float or if they will reference a Scriptable Variable which stores this value and can be linked easily with multiple game objects even across different scenes.
Game Events can be created as Scriptable Objects and easily registered and triggered from any game object. The great advantage being that the object that triggers the game event has no relationship with the listener objects ... they dont even need to be in the same scene.
Imagin you create a capture point in your game and have it raise a Game Event named 'Point Captured' now you or another developer can listen to that event and update UI elements such as score without needing to reference the capture point or even understanding what a capture point is; you only need to know what the event is and it is a Unity Asset available for reference in every scene all the time.
Scriptable Variables have built in Game Events that raise on change of there values giving designers the choice of either updating with every frame as would be common of primative data types or effectivly binding to the value reciving updates only when a change was made.
Imagin you create a Scriptable Variable for player health now the designer working on the health bar UI can simply listen for change of the value, the designer working on the attack damage can simply update the value and the designer working on the low health screen effects can listen to the value. None of these designers need to worry about what the others or doing or how there implamentation works the common element is the Variable; its available for reference in every scene all the time.
Data Serialization Tools
Scriptable Variables can be aranged in a special Scriptable Collection called a Data Library which keys (string name) each variable and can serialize and deserialize to and from byte array or directly to file. This simple approch gives you a code free binary based file save solution that is extreemly tollerent to changes in the data model ... a typical weekness of binary serialization.
Data Libraries let designers add new library values, provide a name for the new field, a default values (as a Scriptable Variable) and an active value (as a Scriptable Variable) and together with the Data Library File Manager handles synchornious and asynchronious serailization to and from byte array or file.
Having data in scriptable objects is great but you still need to get it assigned to your images, labels and other Unity objects. For custom code you can simply change your public float declirations to a public FloatReference and for standard Unity objects we have provided you with a set of simple 'setter' behaviours in addition to the built in change events provided by each variable type. Setters monitor a variable either by event or on update (every frame) and set a specifc value in the target such as image fill, text values, etc.
In most cases Unity standard objects can be diretly set by change event e.g. StringVaraible's change event passes its current value and UI.Text's text value has a built in set method that can recieve this input.