Add Tiled custom types JSON support

[Hinen]

Overview

This PR adds support for importing custom class and enum definitions exported from Tiled's Custom Types Editor.

SuperTiled2Unity already imports custom properties serialized directly in .tmx, .tsx, and template files. With Tiled custom classes, default member properties can live in the custom type definition instead of being duplicated into every asset that uses the class. Unless a value is overridden, or the asset is exported with Tiled's "Resolve object types and properties" option, ST2U may not see those class defaults during import.

This change lets users assign Tiled's exported propertytypes.json file in SuperTiled2Unity Project Settings. During import, ST2U can then load the same custom class defaults and enum metadata that Tiled uses in the editor.

What Changed

• Added a Custom Types JSON field to SuperTiled2Unity Project Settings.
• Added parsing support for Tiled Custom Types JSON exports.
• Supports both exported raw arrays and project-style propertyTypes wrappers.
• Imports custom classes as ST2U custom object types, including class colors and member defaults.
• Imports custom enum definitions, including storageType, values, and valuesAsFlags.
• Preserves propertyType on imported custom properties.
• Resolves enum-backed properties to the enum's configured storage type, such as string or int.
• Applies loaded class defaults through the existing custom property import path.
• Registers the selected JSON file as an import dependency.
• Updates the Custom Properties Viewer to show loaded classes, enum definitions, and enum-backed member metadata.
• Keeps existing Object Types XML support intact.

Example

The screenshots below use a small sample custom type setup to demonstrate the import path.

In Tiled, the sample defines one class, TestClass, with a red class color and three default members: one integer member, one flag enum member, and one regular enum member. The two enum definitions are string-backed, with TestEnum1 using flags and TestEnum2 using a single selected value.

The exported propertytypes.json file is assigned in the new Custom Types JSON field in SuperTiled2Unity Project Settings.

After refreshing, the Custom Properties Viewer shows the loaded class defaults, the class color, the enum-backed member propertyType values, and the enum definitions loaded from the JSON file.

Compatibility

• Existing Object Types XML support remains available.
• Existing serialized custom properties in .tmx, .tsx, and template files continue to work.
• Serialized instance-level properties still take precedence over class defaults.
• Projects that do not assign a Custom Types JSON file behave as before.
• This does not add Unity-side enum dropdown editing, enum value validation, or C# enum generation.

Testing

Manually tested with a Tiled Custom Types JSON export containing:

• one custom class with default members
• class color
• a string-backed flag enum
• a string-backed non-flag enum
• class members referencing those enum property types

Verified in Unity that:

• the exported propertytypes.json can be assigned in the new setting
• the existing Object Types XML setting remains available
• class defaults and class color appear in the Custom Properties Viewer
• enum-backed members preserve their propertyType
• enum-backed members resolve to the enum storage type
• loaded enum definitions show storage type, flag setting, and values

Also checked:

• git diff --check HEAD~1 HEAD

[rasgou]

It would be much better to not even require exporting custom Tiled types as separate files at all, since this info is already embedded into a .tiled-project file. This is instantly auto-saved whenever you edit custom types, without requiring a separate export, and it's stored as a JSON (I think it's the same format as the exported JSON), so it would be a much better workflow.

You just have to recognize a tiled-project file as a Unity asset, then read which folders it references so its settings are applied only to tmx/tsx files under those folders (normally it would be placed at the project's root, like directly under Assets/, to encompass the entire project). This is far better (more discoverable, auto-updated) than hiding config in project settings. You could later move all project config into that asset's importer.

See more info in #311, item 4:

4. Support prefab mapping for the custom classes in .tiled-project files

On that note, this plugin could support .tiled-project files to read the Custom Types Editor directly to map classes, instead of having to export a objecttypes.xml every time. The class->prefab mapping could be set on that file's importer instead of on project settings!

So it would automatically list all custom classes added from Tiled when selecting it in Unity inspector, and allow to assign a prefab to each detected class name.

Any tileset and tilemap that belongs to that .tiled-project (i.e. located under a folder listed on that file's JSON) should use those settings.

This would make the prefab replacement feature much more discoverable than now, where it's under Unity's project settings, kinda hidden.

This PR could be a first step, but ideally, reading the tiled-project is the best workflow.