Lots of Pool updates and extensions. The Pool will now update children automatically, making them far more useful.

Author: photonstorm

v3/src/gameobjects/pool/ObjectPool.js

@@ -1,86 +1,200 @@
 //  Phaser.GameObjects.ObjectPool
 
 var Class = require('../../utils/Class');
-var Sprite = require('../sprite/Sprite');
 
 //  An Object Pool
 
 var ObjectPool = new Class({
 
     initialize:
 
-    function ObjectPool (config)
+    function ObjectPool (manager, classType, maxSize, createCallback, callbackScope)
     {
-        this.processing = false;
+        if (maxSize === undefined) { maxSize = -1; }
+        if (createCallback === undefined) { createCallback = this.makeGameObject; }
+        if (callbackScope === undefined) { callbackScope = this; }
 
-        this._live = [];
-        this._pendingInsertion = [];
-        this._pendingRemoval = [];
-        this._dead = [];
+        this.manager = manager;
+        this.state = manager.state;
 
-        this.classType = Sprite;
+        this.displayList = this.state.sys.displayList;
+        this.updateList = this.state.sys.updateList;
 
-        if (config)
-        {
-            this.createMultiple(config);
-        }
+        this.createCallback = createCallback;
+        this.callbackScope = callbackScope;
+
+        this.maxSize = maxSize;
+
+        this.classType = classType;
+
+        this._list = [];
     },
 
-    //  Allow them to add a Group too
+    makeGameObject: function ()
+    {
+        var gameObject = new this.classType(this.state);
+
+        this.displayList.add(gameObject);
+
+        gameObject.setActive(false);
+        gameObject.setVisible(false);
+
+        return gameObject;
+    },
+
+    //  Add an existing GameObject, or Array or Group of GameObjects into this Pool
     add: function (child)
     {
+        var children;
+
         if (Array.isArray(child))
         {
-            for (var i = 0; i < child.length; i++)
+            children = child;
+        }
+        else if (child.hasOwnProperty('children'))
+        {
+            children = child.children.getArray();
+        }
+        else
+        {
+            children = [ child ];
+        }
+
+        var len = children.length;
+
+        if (this.maxSize > -1)
+        {
+            var free = this.maxSize - this._list.length;
+
+            if (len > free)
             {
-                this.pendingInsertion.push(child[i]);
+                len = free;
             }
         }
-        else
+
+        for (var i = 0; i < len; i++)
         {
-            this.pendingInsertion.push(child);
+            this._list.push(children[i]);
         }
 
         return this;
     },
 
-    get: function ()
+    //  Create X new GameObjects in this Pool if there is capacity to do so
+    create: function (quantity)
     {
+        for (var i = 0; i < quantity; i++)
+        {
+            if (!this.isFull())
+            {
+                this._list.push(this.createCallback.call(this.callbackScope));
+            }
+        }
 
+        return this;
     },
 
-    // getByName: function ()
-    // {
-
-    // },
+    //  Proxy method for sub-classes to override
+    get: function ()
+    {
+        return this.getFreeGameObject();
+    },
 
-    getByName: function ()
+    getFreeGameObject: function ()
     {
+        var gameObject;
+
+        for (var i = 0; i < this._list.length; i++)
+        {
+            gameObject = this._list[i];
 
+            if (!gameObject.active)
+            {
+                gameObject.setActive(true);
+                gameObject.setVisible(true);
+
+                return gameObject;
+            }
+        }
+
+        if (!this.isFull())
+        {
+            gameObject = this.createCallback.call(this.callbackScope);
+
+            gameObject.setActive(true);
+            gameObject.setVisible(true);
+
+            this._list.push(gameObject);
+
+            return gameObject;
+        }
+
+        return null;
     },
 
-    //  Moves from live to pendingRemoval
-    //  is there a reason why it can't do direct to dead?
-    kill: function ()
+    kill: function (gameObject)
     {
-
+        if (this._list.indexOf(gameObject) > -1)
+        {
+            gameObject.setActive(false);
+        }
     },
 
     killAndHide: function (gameObject)
     {
-        gameObject.visible = false;
+        if (this._list.indexOf(gameObject) > -1)
+        {
+            gameObject.setActive(false);
+            gameObject.setVisible(false);
+        }
     },
 
-    createMultiple: function ()
+    isFull: function ()
     {
+        if (this.maxSize === -1)
+        {
+            return false;
+        }
+        else
+        {
+            return (this._list.length === this.maxSize);
+        }
     },
 
     update: function (time, delta)
     {
-        this.processing = true;
+        for (var i = 0; i < this._list.length; i++)
+        {
+            var gameObject = this._list[i];
+
+            if (gameObject.active)
+            {
+                gameObject.update(time, delta);
+            }
+        }
+    },
+
+    getTotalUsed: function ()
+    {
+        var total = 0;
 
+        for (var i = 0; i < this._list.length; i++)
+        {
+            if (this._list[i].active)
+            {
+                total++;
+            }
+        }
+
+        return total;
+    },
+
+    getTotalFree: function ()
+    {
+        var used = this.getTotalUsed();
+        var capacity = (this.maxSize === -1) ? 999999999999 : this.maxSize;
 
-        this.processing = false;
+        return (capacity - used);
     },
 
     destroy: function ()

v3/src/gameobjects/pool/SpritePool.js

@@ -0,0 +1,48 @@
+//  Phaser.GameObjects.SpritePool
+
+var Class = require('../../utils/Class');
+var Sprite = require('../sprite/Sprite');
+var ObjectPool = require('./ObjectPool');
+
+//  An Object Pool
+
+var SpritePool = new Class({
+
+    Extends: ObjectPool,
+
+    initialize:
+
+    function SpritePool (manager, maxSize, quantity, key, frame)
+    {
+        ObjectPool.call(this, manager, Sprite, maxSize, this.makeSprite, this);
+
+        this.defaultKey = key;
+
+        this.defaultFrame = frame;
+    },
+
+    makeSprite: function ()
+    {
+        var gameObject = new this.classType(this.state, 0, 0, this.defaultKey, this.defaultFrame);
+
+        this.displayList.add(gameObject);
+        this.updateList.add(gameObject);
+
+        gameObject.setActive(false);
+        gameObject.setVisible(false);
+
+        return gameObject;
+    },
+
+    get: function (x, y)
+    {
+        var gameObject = this.getFreeGameObject();
+
+        gameObject.setPosition(x, y);
+
+        return gameObject;
+    }
+
+});
+
+module.exports = SpritePool;

v3/src/plugins/PoolManager.js

@@ -1,5 +1,6 @@
 var Class = require('../utils/Class');
 var ObjectPool = require('../gameobjects/pool/ObjectPool');
+var SpritePool = require('../gameobjects/pool/SpritePool');
 
 var PoolManager = new Class({
 
@@ -30,9 +31,20 @@ var PoolManager = new Class({
         return this;
     },
 
-    create: function ()
+    createSpritePool: function (maxSize, key, frame)
     {
-        var pool = new ObjectPool();
+        var pool = new SpritePool(this, maxSize, key, frame);
+
+        this.add(pool);
+
+        return pool;
+    },
+
+    createObjectPool: function (classType, maxSize)
+    {
+        if (maxSize === undefined) { maxSize = -1; }
+
+        var pool = new ObjectPool(this, classType, maxSize);
 
         this.add(pool);
 
@@ -65,8 +77,7 @@ var PoolManager = new Class({
                 this._active.splice(index, 1);
             }
 
-            //  Pool them?
-            // pool.destroy();
+            pool.destroy();
         }
 
         //  Move pending to active