How to use CocosCreator object pool

Preface:

Creating ( cc.instantiate ) and destroying ( node.destroy ) nodes at runtime is very performance-intensive, so in more complex scenes, we usually only create nodes in the scene initialization logic ( onLoad ) and destroy nodes when switching scenes. If we are making an action game with a large number of enemies or bullets that need to be repeatedly generated and destroyed, how can we create and destroy nodes at any time during the game? Here we need the help of object pool.

An object pool is a group of recyclable node objects. We initialize a node object pool by creating an instance of cc.NodePool. Usually when we have multiple prefabs that need to be instantiated, we should create a cc.NodePool instance for each prefab.

When we need to create a node, we apply for a node from the object pool. If there is an idle node in the object pool, the node will be returned to the user. The user adds the new node to the scene node tree through node.addChild.
When we need to destroy a node, we call the put(node) method of the object pool instance and pass in the node instance to be destroyed. The object pool will automatically remove the node from the scene node tree and return it to the object pool.

This achieves the recycling of a few nodes.

Specific operations

Step 1: Prepare the Prefab

Set up the nodes you want to create in advance and make them into Prefab resources. Some of you may not know how to make prefabs?
(Just drag the resources in the resource manager to the hierarchy manager and then drag the nodes back to the resource manager)
This completes the creation of the prefab!

Step 2: Initialize the object pool

In the initialization script of scene loading, we can create the required number of nodes and put them into the object pool:

properties:
    enemyPrefab: cc.Prefab // Required prefab},
onLoad: function () {
    // Create object pool this.enemyPool = new cc.NodePool();
    
    let initCount = 5;
    for (let i = 0; i < initCount; ++i) {
        let enemy = cc.instantiate(this.enemyPrefab); // Create a node this.enemyPool.put(enemy); // Put it into the object pool through the put interface}
}

The number of initial nodes required in the object pool can be controlled according to the needs of the game. It doesn't matter if our estimate of the number of initial nodes is inaccurate, we will deal with it later.

Step 3: Request an object from the object pool

Next, in our runtime code, we can use the following method to obtain the objects stored in the object pool:

createEnemy: function (parentNode) {
    let enemy = null;
    if (this.enemyPool.size() > 0) { // Use the size interface to determine whether there are free objects in the object pool // get() to get the object enemy = this.enemyPool.get();
        
    } else { // If there is no free object, that is, when there are not enough spare objects in the object pool, we use cc.instantiate to recreate enemy = cc.instantiate(this.enemyPrefab);
    }
    enemy.parent = parentNode; // Add the generated enemy to the node tree enemy.getComponent('Enemy').init(); // Next, you can call the script on enemy to initialize it}

The key to using the object pool safely is to always use size to determine whether there is an available object before getting the object. If not, use the normal method of creating nodes. Although it will consume some runtime performance, it is better than crashing the game! Another option is to call get directly. If there is no available node in the object pool, null will be returned. It is also possible to make a judgment at this step.

Step 4: Return the object to the object pool

When we kill the enemy, we need to return the enemy node to the object pool for future recycling. We use this method:

onEnemyKilled: function (enemy) {
    // enemy should be a cc.Node
    this.enemyPool.put(enemy); // As in the initialization method, put the node into the object pool. This method will also call the node's removeFromParent
}

In this way, we have completed a complete cycle, and it doesn’t matter how many monsters the protagonist needs to kill! Putting nodes in and out of the object pool does not incur additional memory management overhead, so you should try to take advantage of it whenever possible.

Step 5: Use components to handle recycling and reuse events

When using the constructor to create an object pool, you can specify a component type or name as the component mounted on the node to handle node recycling and reuse events.

When creating an object pool, you can use:

 let menuItemPool = new cc.NodePool('MenuItem'); //Specify a component type

In this way, when menuItemPool.get() is used to obtain the node, the reuse method in MenuItem will be called to complete the registration of the click event.
When menuItemPool.put(menuItemNode) is used to recycle the node, the unuse method in MenuItem will be called to complete the unregistration of the click event.

cc.Class({
    extends: cc.Component,
    onLoad: function () {
        this.node.selected = false;
        this.node.on(cc.Node.EventType.TOUCH_END, this.onSelect, this.node);
    },
    // put() will call unuse when reclaiming the object pool: function () {
        this.node.off(cc.Node.EventType.TOUCH_END, this.onSelect, this.node);
    },
    // get() will call reuse when getting an object in the object pool: function () {
        this.node.on(cc.Node.EventType.TOUCH_END, this.onSelect, this.node);
    }
});

In addition, cc.NodePool.get() can pass in any number of parameters of different types, which will be passed to the reuse method as is:

// BulletManager.js
let myBulletPool = new cc.NodePool('Bullet'); //Create a bullet object pool let newBullet = myBulletPool.get(this); // Pass in the manager instance for later recycling bullets in the bullet script // Bullet.js
reuse(bulletManager) {
    this.bulletManager = bulletManager; // The management class instance passed in get}
hit () {
    this.bulletManager.put(this.node); // Recover bullets through the management class instance passed in previously}

Step 6: Clear the object pool

If the nodes in the object pool are no longer needed, we can manually clear the object pool and destroy all cached nodes in it:

myPool.clear(); // Call this method to clear the object pool

When the object pool instance is no longer referenced anywhere, the engine's garbage collection system will automatically destroy and recycle the nodes in the object pool. However, the timing of this process is uncontrollable. In addition, if the nodes are referenced by other places, memory leaks may occur. Therefore, it is best to manually call the clear method to clear the cache nodes when switching scenes or when the object pool is no longer needed.

The above is the details of how to use the CocosCreator object pool. For more information about the CocosCreator object pool, please pay attention to other related articles on 123WORDPRESS.COM!