X-Git-Url: https://git.r.bdr.sh/rbdr/serpentity/blobdiff_plain/8af8134e5727b9943ff6261175cf35c311f1ad23..f6b24085682c670793726ef6e4aaf8f8e043fe3d:/dist/serpentity.js?ds=sidebyside diff --git a/dist/serpentity.js b/dist/serpentity.js index 8257ad2..d59bd63 100644 --- a/dist/serpentity.js +++ b/dist/serpentity.js @@ -1,282 +1,111 @@ -'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"; -/* -Serpentity is a simple entity framework inspired by Ash. - -Usage: - - let Serpentity = require('serpentity'); - -## Instantiating an engine - - let engine = Serpentity(); - -Add entities or systems, systems are added with a priority (the smaller -the number, the earlier it will be called): - - engine.addEntity(entityFactory()); - engine.addSystem(new GameSystem(), priority); - -Update all systems: - - engine.update(dt); - -Remove entities or systems: - - engine.removeEntity(entityReference); - engine.removeSystem(systemReference); - -## Creating Entities - -Entities are the basic object of Serpentity, and they do nothing. - - let entity = new Serpentity.Entity(); - -All the behavior is added through components - -## Creating 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) { - this.x = 0; - this.y = 0; - - super(config); - } - }; - -You can add components to entities by using the add method: - - entity.addComponent(new PositionComponent()); - - -Systems can refer to entities by requesting nodes. - -## Working with Nodes - -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; - MovementNode.position = PositionComponent; - MovementNode.motion = MotionComponent; - -You can then request an array of all the nodes representing entities -that comply with that API - - engine.getNodes(MovementNode); - -## Creating Systems -Systems are called on every update, and they use components through nodes. - - let TestSystem = class TestSystem extends Serpentity.System { - added (engine){ - this.nodeList = engine.getNodes(MovementNode); - }, - removed (engine){ - this.nodeList = undefined; - } - update (dt){ - let node; - for (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 - -*/ - -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; }; }(); +/* + * 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 Serpentity = function () { - function Serpentity(config) { - _classCallCheck(this, Serpentity); - - this.systems = []; - this.entities = []; - this._nodeCollections = []; - this._nodeCollectionKeys = []; - - Object.assign(this, config || {}); - } - - /* - * 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 - */ - - - _createClass(Serpentity, [{ - key: 'addSystem', - value: function addSystem(system, priority) { - var lastIndex = void 0, - found = void 0; - - if (this.systems.indexOf(system) >= 0) { - return false; - } - - system.priority = priority; - - found = false; - lastIndex = 0; - - this.systems.some(function findPriority(existingSystem, i) { - lastIndex = i; - if (existingSystem.priority >= system.priority) { - found = true; - return true; - } - }); - - 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 - */ - - }, { - key: 'removeSystem', - value: function removeSystem(system) { - var position = void 0; - - position = this.systems.indexOf(system); - if (position >= 0) { - this.systems[position].removed(this); - this.systems.splice(position, 1); - return true; - } - - return false; - } - - /* - * Adds an entity to the engine, adds to existing node collections - * - * returns true if added, false if already there - */ - - }, { - key: 'addEntity', - value: 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 - */ - - }, { - key: 'removeEntity', - value: function removeEntity(entity) { - var position = void 0; - - position = this.entities.indexOf(entity); - if (position >= 0) { - this._nodeCollections.forEach(function (collection) { - collection.remove(entity); - }); - - this.entities.splice(position, 1); - return true; - } - - return false; - } - - /* - * Given a Node Class, retrieves a list of all the nodes for each - * applicable entity. - */ - - }, { - key: 'getNodes', - value: function getNodes(nodeType) { - var position = void 0, - nodeCollection = void 0; - - position = this._nodeCollectionKeys.indexOf(nodeType); - - if (position >= 0) { - return this._nodeCollections[position].nodes; - } - - 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. - */ +var Component = function Component(config) { + _classCallCheck(this, Component); - }, { - key: 'update', - value: function update(dt) { - this.systems.forEach(function (system) { - system.update(dt); - }); - } - }]); + Object.assign(this, config); +}; - return Serpentity; -}(); +module.exports = Component; -// Add namespaced objects. -if (typeof module !== 'undefined' && undefined.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'); +/***/ }), +/* 1 */ +/***/ (function(module, exports, __webpack_require__) { - module.exports = Serpentity; -} -'use strict'; +"use strict"; -/* global Serpentity */ /* * The entity gives the entity framework its name. It exists only @@ -294,7 +123,7 @@ var Entity = function () { this._componentKeys = []; this._components = []; - Object.assign(this, config || {}); + Object.assign(this, config); } /* @@ -307,6 +136,7 @@ var Entity = function () { _createClass(Entity, [{ key: 'addComponent', value: function addComponent(component) { + if (this._componentKeys.indexOf(component.constructor) >= 0) { return false; } @@ -322,6 +152,7 @@ var Entity = function () { }, { key: 'hasComponent', value: function hasComponent(componentClass) { + if (this._componentKeys.indexOf(componentClass) >= 0) { return true; } @@ -335,6 +166,7 @@ var Entity = function () { }, { key: 'getComponent', value: function getComponent(componentClass) { + var position = this._componentKeys.indexOf(componentClass); if (position >= 0) { return this._components[position]; @@ -345,14 +177,14 @@ var Entity = function () { return Entity; }(); -if (typeof module !== 'undefined' && undefined.module !== module) { - module.exports = Entity; -} else { - Serpentity.Entity = Entity; -} -'use strict'; +module.exports = Entity; + +/***/ }), +/* 2 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; -/* global Serpentity */ /* * A node describes a set of components in order to describe entities @@ -373,13 +205,20 @@ var Node = function () { * false otherwise */ value: function matches(entity) { - var types = this.types; - for (var typeName in types) { - if (types.hasOwnProperty(typeName)) { + 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; - var type = types[typeName]; if (entity.hasComponent(type)) { matched = true; @@ -389,6 +228,19 @@ var Node = function () { return false; } } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } } return true; @@ -400,22 +252,22 @@ var Node = function () { this.types = {}; - Object.assign(this, config || {}); + Object.assign(this, config); } return Node; }(); -if (typeof module !== 'undefined' && undefined.module !== module) { - module.exports = Node; -} else { - Serpentity.Node = Node; -} -'use strict'; +module.exports = Node; -/* global Serpentity */ +/***/ }), +/* 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. * @@ -434,7 +286,7 @@ var NodeCollection = function () { this.nodes = []; this.type = null; - Object.assign(this, config || {}); + Object.assign(this, config); } /* @@ -453,13 +305,33 @@ var NodeCollection = function () { var node = new this.type({}); var types = this.type.types; + var typeNames = Object.keys(types); node.entity = entity; - for (var typeName in types) { - if (types.hasOwnProperty(typeName)) { + 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); @@ -479,20 +351,22 @@ var NodeCollection = function () { }, { key: 'remove', value: function remove(entity) { - var found = -1; - this.nodes.forEach(function (node, i) { + var foundIndex = -1; + + var found = this.nodes.some(function (node, i) { + if (node.entity === entity) { - found = i; + foundIndex = i; + return true; } }); - if (found >= 0) { - this.nodes.splice(found, 1); - return true; + if (found) { + this.nodes.splice(foundIndex, 1); } - return false; + return found; } /* @@ -502,31 +376,32 @@ var NodeCollection = function () { }, { key: '_entityExists', value: function _entityExists(entity) { + var found = false; - var _iteratorNormalCompletion = true; - var _didIteratorError = false; - var _iteratorError = undefined; + var _iteratorNormalCompletion2 = true; + var _didIteratorError2 = false; + var _iteratorError2 = undefined; try { - for (var _iterator = this.nodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { - var node = _step.value; + 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) { - _didIteratorError = true; - _iteratorError = err; + _didIteratorError2 = true; + _iteratorError2 = err; } finally { try { - if (!_iteratorNormalCompletion && _iterator.return) { - _iterator.return(); + if (!_iteratorNormalCompletion2 && _iterator2.return) { + _iterator2.return(); } } finally { - if (_didIteratorError) { - throw _iteratorError; + if (_didIteratorError2) { + throw _iteratorError2; } } } @@ -538,38 +413,14 @@ var NodeCollection = function () { return NodeCollection; }(); -if (typeof module !== 'undefined' && undefined.module !== module) { - module.exports = NodeCollection; -} else { - Serpentity.NodeCollection = NodeCollection; -} -'use strict'; +module.exports = NodeCollection; -/* global Serpentity */ +/***/ }), +/* 4 */ +/***/ (function(module, exports, __webpack_require__) { -/* - * 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. - */ +"use strict"; -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 || {}); -}; - -if (typeof module !== 'undefined' && undefined.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 @@ -626,8 +477,372 @@ var System = function () { return System; }(); -if (typeof module !== 'undefined' && undefined.module !== module) { - module.exports = System; -} else { - Serpentity.System = System; -} \ No newline at end of file +module.exports = System; + +/***/ }), +/* 5 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/* +Serpentity is a simple entity framework inspired by Ash. + +Usage: + + const Serpentity = require('serpentity'); + +## Instantiating an engine + + const engine = new Serpentity(); + +Add entities or systems, systems are added with a priority (the smaller +the number, the earlier it will be called): + + engine.addEntity(entityFactory()); + engine.addSystem(new GameSystem(), priority); + +Update all systems: + + engine.update(dt); + +Remove entities or systems: + + engine.removeEntity(entityReference); + engine.removeSystem(systemReference); + +## Creating Entities + +Entities are the basic object of Serpentity, and they do nothing. + + const entity = new Serpentity.Entity(); + +All the behavior is added through components + +## Creating Components + +Components define data that we can add to an entity. This data will +eventually be consumed by "Systems" + + 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.addComponent(new PositionComponent()); + + +Systems can refer to entities by requesting nodes. + +## Working with Nodes + +Nodes are sets of components that you define, so your system can require +entities that always follow the API defined in the node. + + 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 + + engine.getNodes(MovementNode); + +## Creating Systems + +Systems are called on every update, and they use components through nodes. + + 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 + +*/ + +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); + } + + /* + * 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 + */ + + + _createClass(Serpentity, [{ + key: 'addSystem', + value: function addSystem(system, priority) { + + if (this.systems.indexOf(system) >= 0) { + return false; + } + + system.priority = priority; + + var lastIndex = 0; + + var found = this.systems.some(function (existingSystem, i) { + + lastIndex = i; + if (existingSystem.priority >= system.priority) { + return true; + } + }); + + 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 + */ + + }, { + 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; + } + + return false; + } + + /* + * Adds an entity to the engine, adds to existing node collections + * + * returns true if added, false if already there + */ + + }, { + key: 'addEntity', + value: function addEntity(entity) { + + if (this.entities.indexOf(entity) >= 0) { + return false; + } + this.entities.push(entity); + + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + + try { + for (var _iterator = this._nodeCollections[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var collection = _step.value; + + collection.add(entity); + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + + return true; + } + + /* + * 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; + } + } + } + + this.entities.splice(position, 1); + return true; + } + + return false; + } + + /* + * Given a Node Class, retrieves a list of all the nodes for each + * applicable entity. + */ + + }, { + key: 'getNodes', + value: function getNodes(nodeType) { + + var position = this._nodeCollectionKeys.indexOf(nodeType); + + if (position >= 0) { + return this._nodeCollections[position].nodes; + } + + var nodeCollection = new Serpentity.NodeCollection({ + type: nodeType + }); + + this._nodeCollectionKeys.push(nodeType); + this._nodeCollections.push(nodeCollection); + + var _iteratorNormalCompletion3 = true; + var _didIteratorError3 = false; + var _iteratorError3 = undefined; + + 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; + } + } + } + + return nodeCollection.nodes; + } + + /* + * Calls update for every loaded system. + */ + + }, { + key: 'update', + value: function update(dt) { + var _iteratorNormalCompletion4 = true; + var _didIteratorError4 = false; + var _iteratorError4 = undefined; + + try { + + for (var _iterator4 = this.systems[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) { + var system = _step4.value; + + system.update(dt); + } + } catch (err) { + _didIteratorError4 = true; + _iteratorError4 = err; + } finally { + try { + if (!_iteratorNormalCompletion4 && _iterator4.return) { + _iterator4.return(); + } + } finally { + if (_didIteratorError4) { + throw _iteratorError4; + } + } + } + } + }]); + + 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); + +module.exports = Serpentity; + +/***/ }) +/******/ ]); +}); \ No newline at end of file