Cache

lib/entity_manager.js

@@ -4,6 +4,7 @@ var utils = require("./utils")
 var arrayCreate = utils.arrayCreate
 var arrayExpand = utils.arrayExpand
 var typedArrayExpand = utils.typedArrayExpand
+var FastMap = utils.FastMap
 
 var INITIAL_CAPACITY = 1024
 var ENTITY_DEAD = 0
@@ -22,6 +23,10 @@ function EntityManager(components, storage) {
 
   this._entityPool = []
   this._entityCounter = 0
+
+  this._entityCacheIndices = new Uint32Array(INITIAL_CAPACITY)
+  this._entityCache = FastMap()
+  this._entityCache[0] = []
 }
 
 EntityManager.prototype.create = function() {
@@ -37,6 +42,8 @@ EntityManager.prototype.create = function() {
   var entity = this._entityInst[id]
   this._entityFlag[id] = ENTITY_ALIVE
 
+  this._entityCacheIndices[entity._id] = this._entityCache[0].push(entity) - 1
+
   return entity
 }
 
@@ -54,10 +61,26 @@ EntityManager.prototype.query = function() {
     return []
   }
 
-  var result = []
-  for (var id = 0; id < this._entityCounter; id++) {
-    if (this._entityFlag[id] === ENTITY_ALIVE && (this._entityMask[id] & mask) === mask) {
-      result.push(this._entityInst[id])
+  var allocLen = 0
+  var entityMasks = Object.keys(this._entityCache)
+  for (var index = 0; index < entityMasks.length; index++) {
+    var entityMask = entityMasks[index]
+    if((entityMask & mask) === mask) {
+      allocLen += this._entityCache[entityMask].length
+    }
+  }
+
+  var result = new Array(allocLen)
+  var resultIndex = 0
+
+  for (var index = 0; index < entityMasks.length; index++) {
+    var entityMask = entityMasks[index]
+    if((entityMask & mask) === mask) {
+      var cache = this._entityCache[entityMask]
+      for (var i = 0; i < cache.length; i++) {
+        result[resultIndex] = cache[i]
+        resultIndex++
+      }
     }
   }
 
@@ -76,6 +99,7 @@ EntityManager.prototype._accomodate = function(id) {
 
     this._entityFlag = typedArrayExpand(this._entityFlag, capacity)
     this._entityMask = typedArrayExpand(this._entityMask, capacity)
+    this._entityCacheIndices = typedArrayExpand(this._entityCacheIndices, capacity)
     this._entityInst = arrayExpand(this._entityInst, capacity, null)
     this._storage.resize(capacity)
   }
@@ -84,13 +108,20 @@ EntityManager.prototype._accomodate = function(id) {
 EntityManager.prototype._add = function(id, component) {
   var ctor = component.constructor
   var index = this._components.index(ctor)
+
+  this._cacheRemove(id)
   this._entityMask[id] |= 1 << index
+  this._cacheAdd(id)
   this._storage.set(id, index, component)
 }
 
 EntityManager.prototype._remove = function(id, C) {
   var index = this._components.index(C)
+
+  this._cacheRemove(id)
   this._entityMask[id] &= ~(1 << index)
+  this._cacheAdd(id)
+
   this._storage.delete(id, index)
 }
 
@@ -104,7 +135,31 @@ EntityManager.prototype._get = function(id, C) {
   return this._storage.get(id, index)
 }
 
+EntityManager.prototype._cacheAdd = function(id) {
+  var entity = this._entityInst[id]
+  var cache = this._entityCache[this._entityMask[id]]
+  if (cache === undefined) {
+    this._entityCache[this._entityMask[id]] = []
+  }
+  this._entityCacheIndices[id] = this._entityCache[this._entityMask[id]].push(entity) - 1
+}
+
+EntityManager.prototype._cacheRemove = function(id) {
+  var entity = this._entityInst[id]
+  var cache = this._entityCache[this._entityMask[id]]
+  if (cache.length === 1 || this._entityCacheIndices[id] === cache.length - 1) {
+    cache.pop()
+  } else {
+    var lastCacheElement = cache.pop()
+    this._entityCacheIndices[lastCacheElement._id] = this._entityCacheIndices[entity._id]
+    cache[this._entityCacheIndices[lastCacheElement._id]] = lastCacheElement
+  }
+}
+
 EntityManager.prototype._destroy = function(id) {
+  if (this._entityFlag[id] !== ENTITY_DEAD) {
+    this._cacheRemove(id)
+  }                   
   this._entityFlag[id] = ENTITY_DEAD
   this._entityMask[id] = 0
   this._entityPool.push(id)

lib/utils.js

@@ -2,6 +2,7 @@ exports.arrayCreate = arrayCreate
 exports.arrayExpand = arrayExpand
 exports.arrayFill = arrayFill
 exports.typedArrayExpand = typedArrayExpand
+exports.FastMap = FastMap
 
 // Arrays
 // ------
@@ -32,3 +33,20 @@ function typedArrayExpand(source, length) {
   target.set(source)
   return target
 }
+
+// Maps
+// ------------
+function map() {
+  this.x = 0
+  delete this.x
+}
+
+function FastMap() {
+  var self = new map()
+
+  function ForceEfficientMap() {}
+  ForceEfficientMap.prototype = self
+  new ForceEfficientMap()
+
+  return self
+}

test/entity_manager.js

@@ -114,6 +114,72 @@ describe("EntityManager", function() {
     expect(em.query(Tag)).to.have.length(10)
   })
 
+  it("should return the correct entities when querying", function() {
+    var destroyedEntities = []
+    var aliveEntities = []
+
+    for (var i = 0; i < 10; i++) {
+      var e = em.create()
+      e.add(new Position(0, 0))
+      e.add(new Motion(0, 0))
+      aliveEntities.push(e)
+    }
+
+    // We destroy them in a separate loop to ensure entities aren't picked from the object pool
+    // as this would make the entities in the destroyEntities alive again
+    for (var i = 0; i < 10; i++) {
+      var e = aliveEntities[i]
+      if (i % 2 === 0) {
+        e.destroy()
+        destroyedEntities.push(e)
+      }
+    }
+
+    // It should not return destroyed entities
+    var queryEntities = em.query(Position, Motion)
+    for (var i = 0; i < queryEntities.length; i++) {
+      expect(queryEntities[i].get(Position)).not.to.be.null()
+      expect(queryEntities[i].has(Position)).not.to.be.false()
+      for (var j = 0; j < destroyedEntities.length; j++) {
+        expect(queryEntities[i]).not.to.equal(destroyedEntities[j])
+      }
+    }
+
+    // It should not return duplicate entities
+    var queryEntities = em.query(Position, Motion)
+    for (var i = 0; i < queryEntities.length; i++) {
+      for (var j = i + 1; j < queryEntities.length; j++) {
+        expect(queryEntities[i]).not.to.equal(queryEntities[j])
+      }
+    }
+
+    for (var i = 0; i < queryEntities.length; i++) {
+      queryEntities[i].remove(Position)
+    }
+
+    queryEntities = em.query(Motion)
+
+    // It should return entities with the correct components after removing components
+    for (var i = 0; i < queryEntities.length; i++) {
+      expect(queryEntities[i].get(Position)).to.be.null()
+      expect(queryEntities[i].has(Position)).to.be.false()
+      expect(queryEntities[i].get(Motion)).not.to.be.null()
+      expect(queryEntities[i].has(Motion)).not.to.be.false()
+    }
+
+    for (var i = 0; i < queryEntities.length; i++) {
+      queryEntities[i].add(new Position(0, 0))
+    }
+
+    queryEntities = em.query(Position, Motion)
+
+    // It should return entities with the correct components after adding components
+    for (var i = 0; i < queryEntities.length; i++) {
+      expect(queryEntities[i].get(Position)).not.to.be.null()
+      expect(queryEntities[i].has(Position)).not.to.be.false()
+    }
+  })
+
   it("should expand", function() {
     var capacity = em.capacity