r3-legacy/src/game-lib-entity-manager.js

/**
 * GameLib.EntityManager
 * @param graphics GameLib.D3.Graphics
 * @param apiEntityManager GameLib.API.EntityManager
 * @constructor
 */
GameLib.EntityManager = function(
    graphics,
    apiEntityManager
) {

    this.graphics = graphics;
    this.graphics.isNotThreeThrow();

    if (GameLib.Utils.UndefinedOrNull(apiEntityManager)) {
        apiEntityManager = {};
    }

    GameLib.API.EntityManager.call(
        this,
        apiEntityManager.id,
        apiEntityManager.name,
        apiEntityManager.entities,
        apiEntityManager.parentEntity
    );

    this.entities = this.entities.map(
        function(apiEntity) {

			if (apiEntity instanceof GameLib.API.Entity) {
				return new GameLib.Entity(
					this.graphics,
					apiEntity
				)
			} else {
				console.warn('Entity not of type API.Entity');
				throw new Error('Entity not of type API.Entity');
			}

        }.bind(this)
    );

    this.buildIdToObject();

    this.instance = this.createInstance();
};

GameLib.EntityManager.prototype = Object.create(GameLib.API.EntityManager.prototype);
GameLib.EntityManager.prototype.constructor = GameLib.EntityManager;

/**
 * Creates an Entity Manager instance
 * @returns {*}
 */
GameLib.EntityManager.prototype.createInstance = function() {
    /**
     * Fuck the current ECS bullshit on the internet - both tiny-ecs and ecsjs SUCKS ASS
     */
    return null;
};

/**
 * Creates an GameLib.Entity
 * @returns {*}
 */
GameLib.EntityManager.prototype.createEntity = function(name) {

    var apiEntity = new GameLib.API.Entity(
        null,
        name
    );

    var entity = new GameLib.Entity(
        this.graphics,
        apiEntity
    );

    this.entities.push(entity);

    return entity;
};

/**
 * Removes an entity
 * @param entity GameLib.D3.Entity
 * @returns boolean true if successful
 */
GameLib.EntityManager.prototype.removeEntity = function(entity) {

    var index = this.entities.indexOf(entity);

    if (index == -1) {
        console.log('failed to remove entity : ', entity);
        return false;
    }

    this.entities.splice(index, 1);
    return true;
};

/**
 * Returns all the objects with the following components
 * @param components GameLib.Component[]
 */
GameLib.EntityManager.prototype.query = function(components) {

    var result = this.entities.reduce(
        function(__queryComponents) {
            return function(result, entity) {

                var results = __queryComponents.reduce(

                    function(__entity) {
                        return function(componentResult, queryComponent) {

                            var components = __entity.components.reduce(
                                function(__queryComponent) {
                                    return function(__components, entityComponent) {

                                        if (__queryComponent == entityComponent.constructor) {
                                            // arrow should point towards a window or sergej --->
                                            __components[entityComponent.id] = entityComponent;
                                        }

                                        return __components;

                                    }
                                }(queryComponent),
                                {}
                            );

                            for (var property in components) {
                                if (components.hasOwnProperty(property)) {
                                    componentResult[property] = components[property];
                                }
                            }

                            return componentResult;
                        }
                    }(entity),
                    {}

                );

                for (var property in results) {
                    if (results.hasOwnProperty(property)) {
                        result[property] = results[property];
                    }
                }

                return result;

            }
        }(components),
        {}
    );

    var array = [];

    for (var property in result) {
        if (result.hasOwnProperty(property)) {
            array.push(result[property]);
        }
    }

    return array;
};

/**
 * Converts a GameLib.Entity to GameLib.API.Entity
 * @returns {GameLib.API.EntityManager}
 */
GameLib.EntityManager.prototype.toApiEntityManager = function() {

    var apiEntities = this.entities.map(
        function (entity) {
            return entity.toApiEntity();
        }
    );

    var apiEntityManager = new GameLib.API.EntityManager(
        this.id,
        this.name,
        apiEntities,
        this.parentEntity
    );

    return apiEntityManager;
};

/**
 * Returns an EntityManager from an Object entity manager
 * @param graphics
 * @param objectEntityManager Object
 * @constructor
 */
GameLib.EntityManager.FromObjectEntityManager = function(graphics, objectEntityManager) {

    var apiEntityManager = GameLib.API.EntityManager.FromObjectEntityManager(objectEntityManager);

    var entityManager = new GameLib.EntityManager(
        graphics,
        apiEntityManager
    );

    return entityManager;
};

/**
 * Links object Ids to actual objects
 * @param idToObject
 */
// GameLib.EntityManager.prototype.linkObjects = function(idToObject) {
//
//     this.entities.map(
//         function(entity) {
//             entity.components.map(
//                 function (componentId, index, array) {
//                     if (componentId instanceof GameLib.Component) {
//                         array[index] = componentId;
//                     } else {
//                         array[index] = idToObject[componentId];
//                     }
//
//                     Object.keys(array[index].linkedObjects).map(
//                         function (propertyName) {
//                             array[index][propertyName] = idToObject[array[index][propertyName]];
//                         }
//                     );
//
//                     array[index].loaded = true;
//                 }
//             )
//         }
//     );
//
// };