Arch.System

If only there was a way to organize your queries... wait... there is!

You write query after query all the time to order your subordinates around... it's a pure mess, isn't it? Then just use Arch.System? It's quite simple... With Arch.System you can organize your queries in Systems and call and reuse them at will.

public class MovementSystem : 
{
    private QueryDescription _desc = new QueryDescription().WithAll<Position, Velocity>();
    public MovementSystem(World world) : base(world) {}
    
    // Can be called once per frame
    public override void Update(in )
    {
        // Run query, can also run multiple queries inside the update method
        World.Query(in _desc, (ref Position pos, ref Velocity vel) => {
            pos.X += vel.X;
            pos.Y += vel.Y;
        });  
    }
}

The example above is of course kept simple. You can simply put anything you want to group into such a System, e.g. a System for everything that moves your creatures... another System that contains everything that causes your creatures to suffer damage and heals them etc. There is no limit to your imagination!

Now we already have a MovementSystem, a System that groups everything that makes our Entities move. But how do we integrate this now?

// Create a world and a group of systems which will be controlled 
var world = World.Create();
var _systems = new Group<float>(
    new MovementSystem(world),  
    new PhysicsSystem(world),
    new DamageSystem(world),
    new WorldGenerationSystem(world),
    new OtherGroup(world)
);

_systems.Initialize();                  // Inits all registered systems
_systems.BeforeUpdate(in deltaTime);    // Calls .BeforeUpdate on all systems ( can be overriden )
_systems.Update(in deltaTime);          // Calls .Update on all systems ( can be overriden )
_systems.AfterUpdate(in deltaTime);     // Calls .AfterUpdate on all System ( can be overriden )
_systems.Dispose();                     // Calls .Dispose on all systems ( can be overriden )

A Group<T> can also contain other Group<T>. BeforeUpdate, Update and AfterUpdate should be called at will to update the systems and queries.

And we have already divided our Systems into Group<T>s to bring order into it. What more could you want?