Macro-powered Entity-Component-System framework

This is a Entity-Component-System framework, inspired by the Ash Framework
Thanks to the Haxe macro system we are able to reduce boilerplate code and allow some optimizations.

This is platform-agnostic, you can use it on any targets supported by Haxe (e.g. cpp, js, lua, etc)
This is also game-framework-agnostic, you can use it with any game frameworks such as Kha, OpenFL, Heaps, etc.

Elements of the framework

Engine
The "core" that manages everything

Entity
A container holding various components

Component
Building blocks of an entity, contains attributes/properties but not any logics

System
Logics that operate on Components

Node
A container holding an Entity and the Components of interest. This is mostly for optimization, pre-fetching components from the entity so that we don't need to do so on every iteration.

NodeList
A list of Nodes. The specialized TrackingNodeList will keep track of entities together with their components and add/remove them from the list when appropriate.

Example

import exp.ecs.*;
import exp.ecs.node.*;
import exp.ecs.entity.*;
import exp.ecs.system.*;
import component.*;
import haxe.Timer;

class Playground {
    static function main() {
        // create an engine
        var engine = new Engine();

        // create an entity and adds 2 components to it
        var entity = new Entity();
        entity.add(new Velocity(1, 0));
        entity.add(new Position(0, 0));

        // add entity to engine
        engine.entities.add(entity);

        // create and add 2 systems to engine
        engine.systems.add(new MovementSystem());
        engine.systems.add(new RenderSystem());
        engine.systems.add(new CustomSystem());

        // run the engine
        new Timer(16).run = function() engine.update(16 / 1000);
    }
}

// Use metadata `@:nodes` to create a TrackingNodeList that contains nodes of entities that contains the specified components
// NodeList created this way will be cached in the engine, i.e. multiple systems will share the same NodeList instance if their Node type is the same
class MovementSystem extends System {
    // prepares a NodeList that contains entities having both the Position and Velocity components
    @:nodes var nodes:Node<Position, Velocity>;

    override function update(dt:Float) {
        // on each update we iterate all the nodes and update their Position components
        for(node in nodes) {
            node.position.x += node.velocity.x * dt;
            node.position.y += node.velocity.y * dt;
        }
    }
}

class RenderSystem extends System {
    // prepares a NodeList that contains entities having the Position component
    @:nodes var nodes:Node<Position>;

    override function update(dt:Float) {
        // on each update we iterate all the nodes and print out their positions on screen
        for(node in nodes) {
            trace('${node.entity} @ ${node.position.x}, ${node.position.y}');
        }
    }
}

// Besides using `@:nodes`, you can also create a NodeList manually
class CustomSystem extends System {
    var nodes:NodeList<CustomNode>;

    override function update(dt:Float) {
        for(node in nodes) {
            $type(node); // CustomNode
        }
    }

    override function onAdded(engine) {
        super.onAdded(engine);
        nodes = new TrackingNodeList(engine, CustomNode.new, entity -> entity.has(Position));
    }

    override function onRemoved(engine) {
        super.onRemoved(engine);
        nodes = null;
    }
}

// Manually declare a Node type
class CustomNode implements NodeBase {
    public var entity(default, null):Entity;
    public function new(entity) this.entity = entity;
}