-'use strict';
+(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:
- let Serpentity = require('serpentity');
+ const Serpentity = require('serpentity');
## Instantiating an engine
- let 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):
Entities are the basic object of Serpentity, and they do nothing.
- let entity = new Serpentity.Entity();
+ const entity = new Serpentity.Entity();
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"
- let PositionComponent = class PositionComponent extends Serpentity.Component {
- constructor (config) {
+ const PositionComponent = class PositionComponent extends Serpentity.Component {
+ constructor(config) {
+
this.x = 0;
this.y = 0;
Nodes are sets of components that you define, so your system can require
entities that always follow the API defined in the node.
- let MovementNode = class MovementNode extends Serpentity.Node;
+ const MovementNode = class MovementNode extends Serpentity.Node;
MovementNode.position = PositionComponent;
MovementNode.motion = MotionComponent;
Systems are called on every update, and they use components through nodes.
- let TestSystem = class TestSystem extends Serpentity.System {
- added (engine){
+ const TestSystem = class TestSystem extends Serpentity.System {
+ added(engine){
+
this.nodeList = engine.getNodes(MovementNode);
- },
- removed (engine){
+ }
+
+ removed(engine){
+
this.nodeList = undefined;
}
- update (dt){
- let node;
- for (node of this.nodeList) {
+
+ update(dt){
+
+ for (const node of this.nodeList) {
console.log(`Current position is: ${node.position.x},${node.position.y}`);
}
}
Just run `engine.update(dt)` in your game loop :D
*/
-let Serpentity = class Serpentity {
- constructor (config) {
+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 Serpentity = function () {
+ function Serpentity(config) {
+ _classCallCheck(this, Serpentity);
+
this.systems = [];
this.entities = [];
this._nodeCollections = [];
this._nodeCollectionKeys = [];
- Object.assign(this, config || {});
+ Object.assign(this, config);
}
/*
*
* returns true if added succesfully, false if already added
*/
- addSystem (system, priority) {
- let lastIndex, found;
-
- if (this.systems.indexOf(system) >= 0) {
- return false;
- }
- system.priority = priority;
- found = false;
- lastIndex = 0;
+ _createClass(Serpentity, [{
+ key: 'addSystem',
+ value: function addSystem(system, priority) {
- this.systems.some(function findPriority(existingSystem, i) {
- lastIndex = i;
- if (existingSystem.priority >= system.priority) {
- found = true;
- return true;
+ if (this.systems.indexOf(system) >= 0) {
+ return false;
}
- });
-
- if (!found) {
- lastIndex += 1;
- }
-
- 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 (system) {
- let position;
+ system.priority = priority;
- position = this.systems.indexOf(system);
- if (position >= 0) {
- this.systems[position].removed(this);
- this.systems.splice(position, 1);
- return true;
- }
+ var lastIndex = 0;
- return false;
- }
+ var found = this.systems.some(function (existingSystem, i) {
- /*
- * Adds an entity to the engine, adds to existing node collections
- *
- * returns true if added, false if already there
- */
- 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 (entity) {
- let position;
-
- position = this.entities.indexOf(entity);
- if (position >= 0) {
- this._nodeCollections.forEach(function (collection) {
- collection.remove(entity);
+ lastIndex = i;
+ if (existingSystem.priority >= system.priority) {
+ return true;
+ }
});
- this.entities.splice(position, 1);
- return true;
- }
-
- return false;
- }
-
- /*
- * Given a Node Class, retrieves a list of all the nodes for each
- * applicable entity.
- */
- getNodes (nodeType) {
- let position, nodeCollection;
-
- position = this._nodeCollectionKeys.indexOf(nodeType);
+ if (!found) {
+ lastIndex += 1;
+ }
- if (position >= 0) {
- return this._nodeCollections[position].nodes;
+ this.systems.splice(lastIndex, 0, system);
+ system.added(this);
+ return true;
}
- nodeCollection = new Serpentity.NodeCollection({
- type : nodeType
- });
-
- this._nodeCollectionKeys.push(nodeType);
- this._nodeCollections.push(nodeCollection);
-
- this.entities.forEach(function (entity) {
- nodeCollection.add(entity);
- });
-
- return nodeCollection.nodes;
- }
-
- /*
- * Calls update for every loaded system.
- */
- update (dt) {
- this.systems.forEach(function (system) {
- system.update(dt);
- });
- }
-};
-
-// Add namespaced objects.
-if (typeof module !== 'undefined' && this.module !== module) {
- Serpentity.Component = require('./serpentity/component.js');
- Serpentity.Entity = require('./serpentity/entity.js');
- Serpentity.Node = require('./serpentity/node.js');
- Serpentity.NodeCollection = require('./serpentity/node_collection.js');
- Serpentity.System = require('./serpentity/system.js');
-
- module.exports = Serpentity;
-} else {
- window.Serpentity = Serpentity;
-}
-
-'use strict';
-
-/* global Serpentity */
-
-/*
- * The entity gives the entity framework its name. It exists only
- * to hold components.
- */
-
-let Entity = class Entity {
- constructor (config) {
- this._componentKeys = [];
- this._components = [];
-
- Object.assign(this, config || {});
- }
+ /*
+ * 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
+ */
+
+ }, {
+ key: 'removeSystem',
+ value: function removeSystem(system) {
+
+ var position = this.systems.indexOf(system);
+ if (position >= 0) {
+ this.systems[position].removed(this);
+ this.systems.splice(position, 1);
+ return true;
+ }
- /*
- * Adds a component to the entity.
- *
- * returns true if added, false if already present
- */
- 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
- */
- hasComponent (componentClass) {
- if (this._componentKeys.indexOf(componentClass) >= 0) {
- return true;
- }
- return false;
- }
+ /*
+ * Adds an entity to the engine, adds to existing node collections
+ *
+ * returns true if added, false if already there
+ */
- /*
- * returns the component associated with that key
- */
- getComponent (componentClass) {
- let position;
- position = this._componentKeys.indexOf(componentClass);
- if (position >= 0) {
- return this._components[position];
- }
- }
-};
-
-if (typeof module !== 'undefined' && this.module !== module) {
- module.exports = Entity;
-} else {
- Serpentity.Entity = Entity;
-}
+ }, {
+ key: 'addEntity',
+ value: function addEntity(entity) {
-'use strict';
-
-/* global Serpentity */
-
-/*
- * A node describes a set of components in order to describe entities
- * that include them.
- */
-let Node = class Node {
-
- /*
- * Returns true if the given entity matches the defined protocol,
- * false otherwise
- */
- static matches (entity) {
- let property, types;
+ if (this.entities.indexOf(entity) >= 0) {
+ return false;
+ }
+ this.entities.push(entity);
- types = this.types;
+ var _iteratorNormalCompletion = true;
+ var _didIteratorError = false;
+ var _iteratorError = undefined;
- for (property in types) {
- if (types.hasOwnProperty(property)) {
- let matched, type;
+ try {
+ for (var _iterator = this._nodeCollections[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+ var collection = _step.value;
- matched = false;
- type = types[property];
- if (entity.hasComponent(type)) {
- matched = true;
+ collection.add(entity);
}
- 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;
- }
-
- constructor (config) {
- this.types = {};
+ return true;
+ }
- Object.assign(this, config || {});
- }
-};
+ /*
+ * Removes entity from system, removing from all node collections
+ *
+ * returns true if removed, false if not present
+ */
+
+ }, {
+ 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;
+ }
+ }
+ }
-if (typeof module !== 'undefined' && this.module !== module) {
- module.exports = Node;
-} else {
- Serpentity.Node = Node;
-}
+ this.entities.splice(position, 1);
+ return true;
+ }
-'use strict';
+ return false;
+ }
-/* global Serpentity */
+ /*
+ * Given a Node Class, retrieves a list of all the nodes for each
+ * applicable entity.
+ */
-/*
- * 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.
- */
+ }, {
+ key: 'getNodes',
+ value: function getNodes(nodeType) {
-let NodeCollection = class NodeCollection {
+ var position = this._nodeCollectionKeys.indexOf(nodeType);
- constructor (config) {
- this.nodes = [];
- this.type = null;
+ if (position >= 0) {
+ return this._nodeCollections[position].nodes;
+ }
- Object.assign(this, config || {});
- }
+ 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 (entity) {
+ this._nodeCollectionKeys.push(nodeType);
+ this._nodeCollections.push(nodeCollection);
- if (this.type.matches(entity) && !this._entityExists(entity)) {
- let node, types, property;
+ var _iteratorNormalCompletion3 = true;
+ var _didIteratorError3 = false;
+ var _iteratorError3 = undefined;
- node = new this.type({});
- node.entity = entity;
- types = this.type.types;
+ try {
+ for (var _iterator3 = this.entities[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+ var entity = _step3.value;
- for (property in types) {
- if (types.hasOwnProperty(property)) {
- node[property] = entity.getComponent(types[property]);
+ nodeCollection.add(entity);
+ }
+ } catch (err) {
+ _didIteratorError3 = true;
+ _iteratorError3 = err;
+ } finally {
+ try {
+ if (!_iteratorNormalCompletion3 && _iterator3.return) {
+ _iterator3.return();
+ }
+ } finally {
+ if (_didIteratorError3) {
+ throw _iteratorError3;
+ }
}
}
- this.nodes.push(node);
-
- return true;
+ return nodeCollection.nodes;
}
- return false;
- }
+ /*
+ * Calls update for every loaded system.
+ */
- /*
- * Removes an entity by removing its related node from the list of nodes
- *
- * returns true if it was removed, false otherwise.
- */
- remove (entity) {
- let found;
+ }, {
+ key: 'update',
+ value: function update(dt) {
+ var _iteratorNormalCompletion4 = true;
+ var _didIteratorError4 = false;
+ var _iteratorError4 = undefined;
- found = -1;
- this.nodes.forEach(function (node, i) {
- if (node.entity === entity) {
- found = i;
- }
- });
+ try {
- if (found >= 0) {
- this.nodes.splice(found, 1);
- return true;
- }
-
- return false;
- }
+ for (var _iterator4 = this.systems[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+ var system = _step4.value;
- /*
- * Checks whether we already have nodes for this entity.
- */
- _entityExists (entity) {
- let found, node;
-
- found = false;
- for (node of this.nodes) {
- if (node.entity === entity) {
- found = true;
+ system.update(dt);
+ }
+ } catch (err) {
+ _didIteratorError4 = true;
+ _iteratorError4 = err;
+ } finally {
+ try {
+ if (!_iteratorNormalCompletion4 && _iterator4.return) {
+ _iterator4.return();
+ }
+ } finally {
+ if (_didIteratorError4) {
+ throw _iteratorError4;
+ }
+ }
}
}
+ }]);
- return found;
- }
-};
-
-if (typeof module !== 'undefined' && this.module !== module) {
- module.exports = NodeCollection;
-} else {
- Serpentity.NodeCollection = NodeCollection;
-}
-
-'use strict';
-
-/* global Serpentity */
-
-/*
- * 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.
- */
-
-let Component = class Component {
- constructor (config) {
- Object.assign(this, config || {});
- }
-};
-
-if (typeof module !== 'undefined' && this.module !== module) {
- module.exports = Component;
-} else {
- Serpentity.Component = Component;
-}
-
-'use strict';
-
-/* global Serpentity */
-
-/*
- * 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.
- */
-
-let System = class System {
+ return Serpentity;
+}();
- /*
- * This will be run when the system is added to the engine
- */
- added () {
- // Override with added(engine)
- // Receives an instance of the serpentity engine
- }
-
- /*
- * This will be run when the system is removed from the engine
- */
- removed () {
- // Override with removed(engine)
- // Receives an instance of the serpentity engine
- }
+// 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);
- /*
- * This will run every time the engine's update method is called
- */
- update () {
- // Override with update(dt)
- // Receives a delta of the time
- }
-};
+module.exports = Serpentity;
-if (typeof module !== 'undefined' && this.module !== module) {
- module.exports = System;
-} else {
- Serpentity.System = System;
-}
+/***/ })
+/******/ ]);
+});
\ No newline at end of file
git.r.bdr.sh / rbdr / serpentity / blobdiff