X-Git-Url: https://git.r.bdr.sh/rbdr/serpentity/blobdiff_plain/a2949b6a6621627d0382fd1702d067b7b82322ed..f6b24085682c670793726ef6e4aaf8f8e043fe3d:/dist/serpentity.js diff --git a/dist/serpentity.js b/dist/serpentity.js index 2f91c25..d59bd63 100644 --- a/dist/serpentity.js +++ b/dist/serpentity.js @@ -1,17 +1,501 @@ -if (typeof require !== "undefined") { - require("neon"); -} +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(); + else if(typeof define === 'function' && define.amd) + define([], factory); + else if(typeof exports === 'object') + exports["Serpentity"] = factory(); + else + root["Serpentity"] = factory(); +})(this, function() { +return /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) +/******/ return installedModules[moduleId].exports; +/******/ +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // identity function for calling harmony imports with the correct context +/******/ __webpack_require__.i = function(value) { return value; }; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { +/******/ configurable: false, +/******/ enumerable: true, +/******/ get: getter +/******/ }); +/******/ } +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 5); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/* + * Components store data. Nothing to say here really, just + * inherit and add a prototype, or don't even inherit, see? + * It's just an empty class, so what I'm trying to say is your + * components can be any class whatsoever. + */ + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Component = function Component(config) { + _classCallCheck(this, Component); + + Object.assign(this, config); +}; + +module.exports = Component; + +/***/ }), +/* 1 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/* + * The entity gives the entity framework its name. It exists only + * to hold components. + */ + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Entity = function () { + function Entity(config) { + _classCallCheck(this, Entity); + + this._componentKeys = []; + this._components = []; + + Object.assign(this, config); + } + + /* + * Adds a component to the entity. + * + * returns true if added, false if already present + */ + + + _createClass(Entity, [{ + key: 'addComponent', + value: function addComponent(component) { + + if (this._componentKeys.indexOf(component.constructor) >= 0) { + return false; + } + this._componentKeys.push(component.constructor); + this._components.push(component); + return true; + } + + /* + * returns true if component is included, false otherwise + */ + + }, { + key: 'hasComponent', + value: function hasComponent(componentClass) { + + if (this._componentKeys.indexOf(componentClass) >= 0) { + return true; + } + return false; + } + + /* + * returns the component associated with that key + */ + + }, { + key: 'getComponent', + value: function getComponent(componentClass) { + + var position = this._componentKeys.indexOf(componentClass); + if (position >= 0) { + return this._components[position]; + } + } + }]); + + return Entity; +}(); + +module.exports = Entity; + +/***/ }), +/* 2 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/* + * A node describes a set of components in order to describe entities + * that include them. + */ + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Node = function () { + _createClass(Node, null, [{ + key: 'matches', + + + /* + * Returns true if the given entity matches the defined protocol, + * false otherwise + */ + value: function matches(entity) { + + var typeNames = Object.keys(this.types); + + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + + try { + for (var _iterator = typeNames[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var typeName = _step.value; + + + var type = this.types[typeName]; + var matched = false; + + if (entity.hasComponent(type)) { + matched = true; + } + + if (!matched) { + return false; + } + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + + return true; + } + }]); + + function Node(config) { + _classCallCheck(this, Node); + + this.types = {}; + + Object.assign(this, config); + } + + return Node; +}(); + +module.exports = Node; + +/***/ }), +/* 3 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/* + * Node Collections contain nodes, in order to keep the lists of nodes + * that belong to each type. + * + * It has a type which is the class name of the node, and an array of + * instances of that class. + */ + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var NodeCollection = function () { + function NodeCollection(config) { + _classCallCheck(this, NodeCollection); + + this.nodes = []; + this.type = null; + + Object.assign(this, config); + } + + /* + * Creates a node for an entity if it matches, and adds it to the + * node list. + * + * Returns true if added, false otherwise. + */ + + + _createClass(NodeCollection, [{ + key: 'add', + value: function add(entity) { + + if (this.type.matches(entity) && !this._entityExists(entity)) { + + var node = new this.type({}); + var types = this.type.types; + var typeNames = Object.keys(types); + + node.entity = entity; + + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + + try { + for (var _iterator = typeNames[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var typeName = _step.value; + + node[typeName] = entity.getComponent(types[typeName]); + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + + this.nodes.push(node); + + return true; + } + + return false; + } + + /* + * Removes an entity by removing its related node from the list of nodes + * + * returns true if it was removed, false otherwise. + */ + + }, { + key: 'remove', + value: function remove(entity) { + + var foundIndex = -1; + + var found = this.nodes.some(function (node, i) { + + if (node.entity === entity) { + foundIndex = i; + return true; + } + }); + + if (found) { + this.nodes.splice(foundIndex, 1); + } + + return found; + } + + /* + * Checks whether we already have nodes for this entity. + */ + + }, { + key: '_entityExists', + value: function _entityExists(entity) { + + var found = false; + + var _iteratorNormalCompletion2 = true; + var _didIteratorError2 = false; + var _iteratorError2 = undefined; + + try { + for (var _iterator2 = this.nodes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + var node = _step2.value; + + if (node.entity === entity) { + found = true; + } + } + } catch (err) { + _didIteratorError2 = true; + _iteratorError2 = err; + } finally { + try { + if (!_iteratorNormalCompletion2 && _iterator2.return) { + _iterator2.return(); + } + } finally { + if (_didIteratorError2) { + throw _iteratorError2; + } + } + } + + return found; + } + }]); + + return NodeCollection; +}(); + +module.exports = NodeCollection; + +/***/ }), +/* 4 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/* + * Systems contain most of the logic, and work with nodes in order to + * act and change their values. + * + * You usually want to inherit from this class and override the + * three methods. They are shown here to document the interface. + */ + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var System = function () { + function System() { + _classCallCheck(this, System); + } + + _createClass(System, [{ + key: 'added', + + + /* + * This will be run when the system is added to the engine + */ + value: function added() {} + // Override with added(engine) + // Receives an instance of the serpentity engine + + + /* + * This will be run when the system is removed from the engine + */ + + }, { + key: 'removed', + value: function removed() {} + // Override with removed(engine) + // Receives an instance of the serpentity engine + + + /* + * This will run every time the engine's update method is called + */ + + }, { + key: 'update', + value: function update() { + // Override with update(dt) + // Receives a delta of the time + } + }]); + + return System; +}(); + +module.exports = System; + +/***/ }), +/* 5 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + /* Serpentity is a simple entity framework inspired by Ash. Usage: - require('serpentity'); + const Serpentity = require('serpentity'); ## Instantiating an engine - var engine = Serpentity(); + const engine = new Serpentity(); Add entities or systems, systems are added with a priority (the smaller the number, the earlier it will be called): @@ -32,7 +516,7 @@ Remove entities or systems: Entities are the basic object of Serpentity, and they do nothing. - var entity = new Serpentity.Entity(); + const entity = new Serpentity.Entity(); All the behavior is added through components @@ -41,16 +525,19 @@ All the behavior is added through components Components define data that we can add to an entity. This data will eventually be consumed by "Systems" - Class("PositionComponent").inherits(Serpentity.Component)({ - prototype : { - x : 0, - y : 0 - } - }); + const PositionComponent = class PositionComponent extends Serpentity.Component { + constructor(config) { + + this.x = 0; + this.y = 0; + + super(config); + } + }; You can add components to entities by using the add method: - entity.add(new PositionComponent()); + entity.addComponent(new PositionComponent()); Systems can refer to entities by requesting nodes. @@ -60,12 +547,9 @@ Systems can refer to entities by requesting nodes. Nodes are sets of components that you define, so your system can require entities that always follow the API defined in the node. - Class("MovementNode").inherits(Serpentity.Node)({ - types : { - position : PositionComponent, - motion : MotionComponent - } - }); + const MovementNode = class MovementNode extends Serpentity.Node; + MovementNode.position = PositionComponent; + MovementNode.motion = MotionComponent; You can then request an array of all the nodes representing entities that comply with that API @@ -76,434 +560,289 @@ that comply with that API Systems are called on every update, and they use components through nodes. - Class("TestSystem").inherits(Serpentity.System)({ - prototype : { - added : function added(engine){ - this.nodeList = engine.getNodes(MovementNode); - }, - removed : function removed(engine){ - this.nodeList = undefined; - } - update : function update(dt){ - this.nodeList.forEach(function (node) { - console.log("Current position is: " + node.position.x + "," + node.position.y); - }); - } + const TestSystem = class TestSystem extends Serpentity.System { + added(engine){ + + this.nodeList = engine.getNodes(MovementNode); + } + + removed(engine){ + + this.nodeList = undefined; + } + + update(dt){ + + for (const node of this.nodeList) { + console.log(`Current position is: ${node.position.x},${node.position.y}`); } - }); + } + }; ## That's it Just run `engine.update(dt)` in your game loop :D */ -Class("Serpentity")({ - prototype : { - systems : null, - entities : null, - _nodeCollections : null, - _nodeCollectionKeys : null, - - init : function init(config) { - var property; - - config = config || {}; - - this.systems = []; - this.entities = []; - this._nodeCollections = []; - this._nodeCollectionKeys = []; - - for (property in config) { - if (config.hasOwnProperty(property)) { - this[property] = config[property]; - } - } - }, - - /* - * Adds a system to the engine, so its update method will be called - * with the others. Triggers added hook. - * - * returns true if added succesfully, false if already added - */ - addSystem : function addSystem(system, priority) { - var lastIndex, found; - - if (this.systems.indexOf(system) >= 0) { - return false; - } - system.priority = priority; +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); - found = false; - lastIndex = 0; +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - this.systems.some(function findPriority(existingSystem, i) { - lastIndex = i; - if (existingSystem.priority >= system.priority) { - found = true; - return true; - } - }); +var Serpentity = function () { + function Serpentity(config) { + _classCallCheck(this, Serpentity); - if (!found) { - lastIndex += 1 - } + this.systems = []; + this.entities = []; + this._nodeCollections = []; + this._nodeCollectionKeys = []; - this.systems.splice(lastIndex, 0, system); - system.added(this); - return true; - }, - - /* - * Removes a system from the engine, so its update method will no - * longer will be called. Triggers the removed hook. - * - * returns true if removed succesfully, false if already added - */ - removeSystem : function removeSystem(system) { - var position; - - position = this.systems.indexOf(system); - if (position >= 0) { - this.systems[position].removed(this); - this.systems.splice(position, 1); - return true; - } + Object.assign(this, config); + } - return false; - }, - - /* - * Adds an entity to the engine, adds to existing node collections - * - * returns true if added, false if already there - */ - addEntity : function addEntity(entity) { - if (this.entities.indexOf(entity) >= 0) { - return false; - } - this.entities.push(entity); - - this._nodeCollections.forEach(function (collection) { - collection.add(entity); - }); - - return true; - }, - - /* - * Removes entity from system, removing from all node collections - * - * returns true if removed, false if not present - */ - removeEntity : function removeEntity(entity) { - var position; - - position = this.entities.indexOf(entity); - if (position >= 0) { - this._nodeCollections.forEach(function (collection) { - collection.remove(entity); - }); - - this.entities.splice(position, 1); - return true; - } + /* + * Adds a system to the engine, so its update method will be called + * with the others. Triggers added hook. + * + * returns true if added succesfully, false if already added + */ - return false; - }, - /* - * Given a Node Class, retrieves a list of all the nodes for each - * applicable entity. - */ - getNodes : function getNodes(nodeType) { - var position, nodeCollection; + _createClass(Serpentity, [{ + key: 'addSystem', + value: function addSystem(system, priority) { - position = this._nodeCollectionKeys.indexOf(nodeType); + if (this.systems.indexOf(system) >= 0) { + return false; + } - if (position >= 0) { - return this._nodeCollections[position].nodes; - } + system.priority = priority; - nodeCollection = new Serpentity.NodeCollection({ - type : nodeType, - }); + var lastIndex = 0; - this._nodeCollectionKeys.push(nodeType); - this._nodeCollections.push(nodeCollection); + var found = this.systems.some(function (existingSystem, i) { - this.entities.forEach(function (entity) { - nodeCollection.add(entity); - }); + lastIndex = i; + if (existingSystem.priority >= system.priority) { + return true; + } + }); - return nodeCollection.nodes; - }, + if (!found) { + lastIndex += 1; + } - /* - * Calls update for every loaded system. - */ - update : function update(dt) { - this.systems.forEach(function (system) { - system.update(dt); - }); - } + this.systems.splice(lastIndex, 0, system); + system.added(this); + return true; } -}); - -if (typeof require !== "undefined") { - require("./component.js"); - require("./entity.js"); - require("./node.js"); - require("./node_collection.js"); - require("./system.js"); -} -/* - * The entity gives the entity framework its name. It exists only - * to hold components. - */ -Class(Serpentity, "Entity")({ - prototype : { - _components : null, - _componentKeys : null, + /* + * Removes a system from the engine, so its update method will no + * longer will be called. Triggers the removed hook. + * + * returns true if removed succesfully, false if already added + */ - init : function init(config) { - var property; + }, { + key: 'removeSystem', + value: function removeSystem(system) { - this._componentKeys = []; - this._components = []; + var position = this.systems.indexOf(system); + if (position >= 0) { + this.systems[position].removed(this); + this.systems.splice(position, 1); + return true; + } - for (property in config) { - if (config.hasOwnProperty(property)) { - this[property] = config[property]; - } - } - }, - - /* - * Adds a component to the entity. - * - * returns true if added, false if already present - */ - add : function add(component) { - if (this._componentKeys.indexOf(component.constructor) >= 0) { - return false; - } - this._componentKeys.push(component.constructor); - this._components.push(component); - return true; - }, - - /* - * returns true if component is included, false otherwise - */ - hasComponent : function hasComponent(componentClass) { - if (this._componentKeys.indexOf(componentClass) >= 0) { - return true; - } - return false; - }, - - /* - * returns the component associated with that key - */ - getComponent : function getComponent(componentClass) { - var position; - position = this._componentKeys.indexOf(componentClass); - if (position >= 0) { - return this._components[position]; - } - } + return false; } -}); - -/* - * A node describes a set of components in order to describe entities - * that include them. - */ -Class(Serpentity, "Node")({ /* - * Returns true if the given entity matches the defined protocol, - * false otherwise + * Adds an entity to the engine, adds to existing node collections + * + * returns true if added, false if already there */ - matches : function matches(entity) { - var property, matched, types; - types = this.types; + }, { + key: 'addEntity', + value: function addEntity(entity) { - for (property in this.types) { + if (this.entities.indexOf(entity) >= 0) { + return false; + } + this.entities.push(entity); - if (this.types.hasOwnProperty(property)) { - matched = false; + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; - if (entity.hasComponent(types[property])) { - matched = true; - } + try { + for (var _iterator = this._nodeCollections[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var collection = _step.value; - if (!matched) { - return false; - } - } - } - - return true; - }, - - prototype : { - - types : null, + collection.add(entity); + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } - init : function (config) { - var property; + return true; + } - this.types = {}; + /* + * Removes entity from system, removing from all node collections + * + * returns true if removed, false if not present + */ - for (property in this.constructor) { - if (this.constructor.hasOwnProperty(property)) { - this.types[property] = this.constructor[property]; - } + }, { + key: 'removeEntity', + value: function removeEntity(entity) { + + var position = this.entities.indexOf(entity); + if (position >= 0) { + var _iteratorNormalCompletion2 = true; + var _didIteratorError2 = false; + var _iteratorError2 = undefined; + + try { + for (var _iterator2 = this._nodeCollections[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + var collection = _step2.value; + + collection.remove(entity); + } + } catch (err) { + _didIteratorError2 = true; + _iteratorError2 = err; + } finally { + try { + if (!_iteratorNormalCompletion2 && _iterator2.return) { + _iterator2.return(); + } + } finally { + if (_didIteratorError2) { + throw _iteratorError2; } + } } + + this.entities.splice(position, 1); + return true; + } + + return false; } -}); -/* - * Node Collections contain nodes, in order to keep the lists of nodes - * that belong to each type. - * - * It has a type which is the class name of the node, and an array of - * instances of that class. - */ -Class(Serpentity, "NodeCollection")({ - prototype : { - type : null, - nodes : null, + /* + * Given a Node Class, retrieves a list of all the nodes for each + * applicable entity. + */ - init : function init(config) { - var property; + }, { + key: 'getNodes', + value: function getNodes(nodeType) { - config = config || {}; + var position = this._nodeCollectionKeys.indexOf(nodeType); - this.nodes = []; + if (position >= 0) { + return this._nodeCollections[position].nodes; + } - for (property in config) { - if (config.hasOwnProperty(property)) { - this[property] = config[property]; - } - } - }, + var nodeCollection = new Serpentity.NodeCollection({ + type: nodeType + }); - /* - * Creates a node for an entity if it matches, and adds it to the - * node list. - * - * Returns true if added, false otherwise. - */ - add : function add(entity) { - var node, types, property; + this._nodeCollectionKeys.push(nodeType); + this._nodeCollections.push(nodeCollection); - if (this.type.matches(entity) && !this._entityExists(entity)) { - node = new this.type({}); + var _iteratorNormalCompletion3 = true; + var _didIteratorError3 = false; + var _iteratorError3 = undefined; - node.entity = entity; + try { + for (var _iterator3 = this.entities[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { + var entity = _step3.value; + + nodeCollection.add(entity); + } + } catch (err) { + _didIteratorError3 = true; + _iteratorError3 = err; + } finally { + try { + if (!_iteratorNormalCompletion3 && _iterator3.return) { + _iterator3.return(); + } + } finally { + if (_didIteratorError3) { + throw _iteratorError3; + } + } + } - types = this.type.types; + return nodeCollection.nodes; + } - for (property in types) { - if (types.hasOwnProperty(property)) { - node[property] = entity.getComponent(types[property]); - } - } + /* + * Calls update for every loaded system. + */ - this.nodes.push(node); + }, { + key: 'update', + value: function update(dt) { + var _iteratorNormalCompletion4 = true; + var _didIteratorError4 = false; + var _iteratorError4 = undefined; - return true; - } + try { - return false; - }, - - /* - * Removes an entity by removing its related node from the list of nodes - * - * returns true if it was removed, false otherwise. - */ - remove : function (entity) { - var found; - found = -1; - this.nodes.forEach(function (node, i) { - if (node.entity === entity) { - found = i; - } - }); - - if (found >= 0) { - this.nodes.splice(found, 1); - return true; - } + for (var _iterator4 = this.systems[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) { + var system = _step4.value; - return false; - }, - - /* - * Checks whether we already have nodes for this entity. - */ - _entityExists : function entityExists(entity) { - var found; - found = false; - this.nodes.forEach(function (node) { - if (node.entity === entity) { - found = true; - } - }); - - return found; + system.update(dt); } + } catch (err) { + _didIteratorError4 = true; + _iteratorError4 = err; + } finally { + try { + if (!_iteratorNormalCompletion4 && _iterator4.return) { + _iterator4.return(); + } + } finally { + if (_didIteratorError4) { + throw _iteratorError4; + } + } + } } -}); + }]); -/* - * Components store data. Nothing to say here really, just - * inherit and add a prototype, or don't even inherit, see? - * It's just an empty class, so what I'm trying to say is your - * components can be any class whatsoever. - */ -Class(Serpentity, "Component")({ + return Serpentity; +}(); -}); +// Add namespaced objects. +Serpentity.Component = __webpack_require__(0); +Serpentity.Entity = __webpack_require__(1); +Serpentity.Node = __webpack_require__(2); +Serpentity.NodeCollection = __webpack_require__(3); +Serpentity.System = __webpack_require__(4); -/* - * Systems contain most of the logic, and work with nodes in order to - * act and change their values. - * - * You usually want to inherit from this class and override the - * three methods. - */ -Class(Serpentity, "System")({ - prototype : { - - /* - * This will be run when the system is added to the engine - */ - added : function added(engine) { - // Override - }, - - /* - * This will be run when the system is removed from the engine - */ - removed : function removed(engine) { - // Override - }, - - /* - * This will run every time the engine's update method is called - */ - update : function update(dt) { - // Override - } - } -}); +module.exports = Serpentity; + +/***/ }) +/******/ ]); +}); \ No newline at end of file