Unity

ScriptableObjects, written into your project.

It reads your ScriptableObject classes from your C#, writes new objects as .asset files Unity opens with your script attached, and changes values in place when a formula moves.

What it reads from a Unity project.

Open the project folder in the app. It knows a Unity project by ProjectSettings/ProjectVersion.txt, reads the C# under it, and skips folders that hold only build output, like Library and Temp. Your existing .asset files are the measure every new number is checked against.

Read as data

Classes that extend ScriptableObject.
Classes marked [CreateAssetMenu] or [Serializable].
Public fields, and private ones marked [SerializeField], as Unity serialises them.

Passed over

MonoBehaviours: they are behaviour in a scene, not data.
Editor code: Editor, EditorWindow, PropertyDrawer.
Interfaces.

A [Range(min, max)] is a limit: every new object is checked against it, and a retune that would cross it is clamped and says so. A [Tooltip] becomes the field’s description.

What it gives you.

The object is Emberbrand, from the demo’s saved run. Both files were written by the app’s own code when this page was built: the first is what you copy out, the second is what Save to project writes into a project that holds the first.

WeaponDefinition.csScriptableObject plus a factory, since .asset files cannot be pasted. Save it as the file name shown: Unity only binds a ScriptableObject to a file named after its class.

using UnityEngine;

public enum WeaponRarity
{
    Common,
    Uncommon,
    Rare,
    Epic,
    Legendary,
}

public enum WeaponDamageType
{
    Slashing,
    Piercing,
    Bludgeoning,
    Arcane,
    Fire,
    Frost,
    Lightning,

119 more lines

The full code comes with the application, which a seat covers.

See pricing

What Save to project does.

One .asset per object, in the folder your existing assets of that class are in, each with its own .meta and a fresh guid, so the editor and version control agree from the first import. Each asset’s internal name is its file name, as Unity expects, so the Inspector raises no name warning.
Each asset points at your class through the guid in your script’s .meta. If that .meta cannot be found, it writes nothing and says so, rather than leave assets that import with a missing script.
Enums go in as the numbers Unity stores, your own assigned numbers where you declared them. Booleans go in as 0 and 1, and vectors as {x: 96, y: 96}.
Every file is shown before it is written, and whether it is new or replaces one. You can undo the save straight afterwards.

When a formula changes.

A retune changes the field’s line in each .asset it moves, in the file that asset already is, and nothing else. The .meta is never touched, so each asset keeps its guid, and every scene, prefab and loot table that points at it still does.

Apply cannot be undone from inside the app, so commit first.

How a retune works, step by step

Try it on your Unity project.

The evaluation is the whole app for 14 days, with no card. The guide covers the first ten minutes.

Try it free for 14 days Open the demo

Also for Unreal and Godot, and for any other engine through JSON.