Implement user properties using bevy_reflect

[adrien-bon]

Initial idea from @Niashi24

I saw your project and I thought using Tiled custom properties to map to bevy components/bundles was a good idea, but it involved a good amount of boilerplate and setup (creating the custom properties and using macros mainly), and I got inspired from Blenvy to implement the whole system using bevy_reflect.

Right now I have a working prototype (which you can find here, check loader and properties folder for most of the changes) for exporting custom properties as a json file that you can import into Tiled, add those properties in Tiled to the map, layers, and objects (tiles are still WIP though shouldn't be too difficult?), and then load those in Bevy as either components, bundles, or resources, and add them to the corresponding entity.

On the Tiled side:
standard types like int, float, bool, string map to their Rust counterparts (i32/i16/u32/etc, f32/f64, bool, String)
color maps to bevy_color::color::Color
file maps to Handle and PathBuf
object maps to either Entity (panics on load if not assigned) or Option

On the Rust side:
Structs, Tuples, TupleStructs, Arrays are supported as Tiled Classes
Simple Enums (enum's with only Unit variants) are supported as Tiled Enums
Non-simple enums are not implemented right now but I can probably implement them by making Tiled classes for each non-unit variant and then a Tiled Enum for the variant
Lists are not supported because they are not in Tiled currently but they are marked to release in the next version so when those are implemented it shouldn't be too difficult to add on
Maps are not supported in Tiled but they can be added with lists when that gets supported by having a list of pairs
How it works:
Run your project once to output a tiled_type_export.json file that can be imported into Tiled
Add components, bundles, or resources to your layers/tiles/objects
When the map is loaded it will deserialize the component/bundle/resource
To support entity references, when the map is spawned in the world it will "hydrate" the map with just a hashmap<u32, Entity>

Upsides of the bevy_reflect approach:
No macros (hard to maintain and comes with compilation woes)
Don't need to create bundles for if you want to add any existing components
Entity references are huge imo

Downsides:
Probably decreased speed to load in maps?
all the deserializing of types is done at load time, the only thing it does when spawning in a map is update the entity references.

Imo the new approach is well worth the loading downside, and honestly I think we could probably do away with the old solution entirely.

I haven't gotten too familiar with your codebase + I'm 2 weeks behind on commits + I'm usually pretty busy with University work so feel free to bring things over into the main project yourself and do it the way you want if you'd like.

Next steps:
Get non-unit enums working
Add tile functionality
add configuration because a lot of it is hardcoded
Hot reloading
Not sure how this might work, perhaps some kind of Static component that tells it this object/layer/tile doesn't change and can be reloaded? Maintaining object references would be the hard part

The initial prototype is now on a dedicated dev branch so we can open PR on it.

This discussion is to track overall progress and what's left to do before release to main.

• Non-unit enums @Niashi24
• Add tile functionality @adrien-bon
• Configuration
• Hot reloading
• Triggers "Created" events
• Old code cleanup
• Update examples / documentation

[adrien-bon]

Merged #35 for tiles custom properties.
Openned a new PR #36 for reworking physics, updating examples and adding a way to configure properties mapping (where we store tiled type export file).
Next steps: cleanup old code + update documentation.

[adrien-bon]

Merged #36 and pushed documentation / cleanup directly on the feat/bevy_reflect_for_properties branch.
Next steps: assigne default value for Tiled properties + restrict Res to map only + finish documentation on user properties

[adrien-bon]

Provided default value for Tiled export + try to use Rust default value when loading a property without all its fields.

Remaining "mandatory" points:

• document all of this in the book / the API documentaiton
• make sure all of that actually works (probably going to add more unit tests)

Remaining "nice to have" stuff:

• handle "non-unit" enums
• only export Component / Bundle / Resource reflects (would need to "discover" types recursively)

[adrien-bon]

Everything was merged to dev branch.
Closing this discussion, I'll open dedicated issues for remaining stuff.