DefaultEcs v0.15.0 breaking changes

[Doraku]

Don't know if someone will actually read this but with the possibility to have a real place for discussion in github now I thought it would be a good idea to expose what are the changes coming with the next version and the reasoning behind them them.

Breaking changes

• removed Entity.SetAsChildOf
• removed Entity.SetAsParentOf
• removed Entity.RemoveFromChildrenOf
• removed Entity.RemoveFromParentsOf
• removed Entity.GetChildren
• removed EntityRecord.SetAsChildOf
• removed EntityRecord.SetAsParentOf
• removed EntityRecord.RemoveFromChildrenOf
• removed EntityRecord.RemoveFromParentsOf

Since its inception I was always displeased with the way I implemented the parent/child relationship in DefaultEcs. It was something really specific, ignored the enable/disable state of entities and created garbage memory if used. I finally decided to remove this feature from DefaultEcs, and offer an exemple on how to add it back if you need it in the extension project here.
In the end I think this feature is highly specific of your engine and shouldn't be part of a base framework.

• changed TextSerializer format for pure List and Dictionary types
• changed TextSerializer format for Guid

The TextSerializer is supposed to be easy to read and edit by end but because List, Dictionary and Guid were serialized as any type, you were shown all their fields which was completely unnecessary. This aims to change this shortcoming.

• changed EntityCommandRecorder.CreateEntity parameters, now takes directly the world on which to create the entity
• changed EntityCommandRecorder.Execute parameters, now takes no parameter

Before you could later decide on which world to create your entities with an EntityCommandRecorder. At the beginning I had the thought to turn the recorder as a factory you could reuse multiple times where this would make sens but this offer no benefit to just calling your static method as a factory or even create a really simple model to schematize this factory in an editor so I just scrapped this idea. Thus keeping the world parameter of the Execute method made little sens instead of providing the world when creating an entity in the recorder.

• renamed AEntitySystem to AEntitySetSystem
• fused AEntityBufferedSystem into AEntitySetSystem
• renamed EntitiesMap to EntityMultiMap
• renamed AEntitiesSystem to AEntityMultiMapSystem
• fused AEntitiesBufferedSystem into AEntityMultiMapSystem

Actually went with the rename, makes things clearer and more homogeneous.

DefaultEcs.Analyzer sister project

This is probably the actual big new thing that will come with this release. This analyzer will include some checks about the correct usage of DefaultEcs but also a roslyn code generator to greatly reduce boilerplate code and remove reflection usage when possible (to help AoT platform that can't rely on jitter).
For example instead of having systems declared as such:

        private sealed class TestSystem : AEntitySystem<float>
        {
            public TestSystem(World world, IParallelRunner runner)
                : base(world.GetEntities().With<Position>().With<Speed>().AsSet(), runner)
            { }

            protected override void Update(float state, ReadOnlySpan<Entity> entities)
            {
                foreach (ref readonly Entity entity in entities)
                {
                    Speed speed = entity.Get<Speed>();
                    ref Position position = ref entity.Get<Position>();

                    position.X += speed.X * state;
                    position.Y += speed.Y * state;
                }
            }
        }

you will be able to declare them as

        private sealed partial class GeneratorSystem : AEntitySystem<float>
        {
            [Update]
            private static void Update(float state, Speed speed, ref Position position)
            {
                position.X += speed.X * state;
                position.Y += speed.Y * state;
            }
        }

The EntitySet composition will be automatically deduced from the parameters of the method decorated with the Update attribute, the generator taking care of the constructor and the override of entity systems.