-'use strict';
+// Export submodules
+export { Component } from './serpentity/component.js';
+export { Entity } from './serpentity/entity.js';
+export { Node } from './serpentity/node.js';
+export { System } from './serpentity/system.js';
+
+import { NodeCollection } from './serpentity/node_collection.js';
/*
Serpentity is a simple entity framework inspired by Ash.
Usage:
- let Serpentity = require('serpentity');
+ import Serpentity from '@serpentity/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();
+ import { Entity } from '@serpentity/serpentity';
+ const entity = new 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) {
+ import { Component } from '@serpentity/serpentity';
+ const PositionComponent = class PositionComponent extends 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;
+ import { Node } from '@serpentity/serpentity';
+ const MovementNode = class MovementNode extends 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){
+ import { System } from '@serpentity/serpentity';
+ const TestSystem = class TestSystem extends 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 {
+export default class Serpentity {
+
+ constructor(config) {
- constructor (config) {
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;
+ addSystem(system, priority) {
if (this.systems.indexOf(system) >= 0) {
return false;
system.priority = priority;
- found = false;
- lastIndex = 0;
+ let lastIndex = 0;
+
+ const found = this.systems.some((existingSystem, i) => {
- this.systems.some(function findPriority(existingSystem, i) {
lastIndex = i;
if (existingSystem.priority >= system.priority) {
- found = true;
return true;
}
});
*
* returns true if removed succesfully, false if already added
*/
- removeSystem (system) {
- let position;
+ removeSystem(system) {
- position = this.systems.indexOf(system);
+ const position = this.systems.indexOf(system);
if (position >= 0) {
this.systems[position].removed(this);
this.systems.splice(position, 1);
*
* returns true if added, false if already there
*/
- addEntity (entity) {
+ addEntity(entity) {
+
if (this.entities.indexOf(entity) >= 0) {
return false;
}
+
this.entities.push(entity);
- this._nodeCollections.forEach(function (collection) {
+ for (const collection of this._nodeCollections) {
collection.add(entity);
- });
+ }
return true;
}
*
* returns true if removed, false if not present
*/
- removeEntity (entity) {
- let position;
+ removeEntity(entity) {
- position = this.entities.indexOf(entity);
+ const position = this.entities.indexOf(entity);
if (position >= 0) {
- this._nodeCollections.forEach(function (collection) {
+ for (const collection of this._nodeCollections) {
collection.remove(entity);
- });
+ }
this.entities.splice(position, 1);
return true;
* Given a Node Class, retrieves a list of all the nodes for each
* applicable entity.
*/
- getNodes (nodeType) {
- let position, nodeCollection;
+ getNodes(nodeType) {
- position = this._nodeCollectionKeys.indexOf(nodeType);
+ const position = this._nodeCollectionKeys.indexOf(nodeType);
if (position >= 0) {
return this._nodeCollections[position].nodes;
}
- nodeCollection = new Serpentity.NodeCollection({
- type : nodeType
+ const nodeCollection = new NodeCollection({
+ type: nodeType
});
this._nodeCollectionKeys.push(nodeType);
this._nodeCollections.push(nodeCollection);
- this.entities.forEach(function (entity) {
+ for (const entity of this.entities) {
nodeCollection.add(entity);
- });
+ }
- return nodeCollection.nodes;
+ return nodeCollection;
}
/*
* Calls update for every loaded system.
*/
- update (dt) {
- this.systems.forEach(function (system) {
+ update(dt) {
+
+ for (const system of this.systems) {
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;
}
git.r.bdr.sh / rbdr / serpentity / blobdiff