Simple AndEngine Game V1.5 [using pools]

This is not considered as a whole tutorial, this is some kind of fixing some stupid stuff we did back in the the previous one and caused android to struggle [sorry android >_<] and reduced performance
If you ever checked the logcat while the application is running, you may have noticed that the Garbage collector was running a lot , that’s because we were creating objects and just leaving them floating around, when the android system needs extra ram [or when it just decides that it wants to run the garbage collector just for the heck of it] it’d remove those objects we created and we create some more .. so here we are presenting the solution for this:

Introducing Awesome Recycling Thingie !!!! [or just pools]

The idea of pools is to create an object on need, when you are done with it you give it back to the pool for reuse
I found a great tutorial on using Generic pools from c0deattack where he describes using bullets pools as:

Game: I need a bullet! Mr. Object Pool can I have an instance of a Bullet please?
Mr. Object Pool: Let me check my pool…I don’t have spare Bullets, I’ll create a new Bullet for you
Game: Thanks!
Game: Mr. Object Pool, this bullet has moved offscreen so I don’t need it anymore, please recycle it for me
Mr. Object Pool: Ok, thanks, I’ll put that instance in my pool
Game: Hey, I need another Bullet again
Mr. Object Pool: No problem, I have one in my pool which you gave me, I don’t need to waste time making a new Bullet, you can have this one!

perfect , right ?
it’s actually quite easy to use too ..

Creating the pool

Create a new class that extends GenericPool, I named it ProjectilesPool, here’s the whole class

public class ProjectilesPool extends GenericPool<Sprite> {
    private TextureRegion mTextureRegion;

    public ProjectilesPool(TextureRegion pTextureRegion) {
        if (pTextureRegion == null) {
            // Need to be able to create a Sprite so the Pool needs to have a TextureRegion
                throw new IllegalArgumentException("The texture region must not be NULL");
        }
        mTextureRegion = pTextureRegion;
    }

    /** Called when a projectile is required but there isn't one in the pool */
    @Override
    protected Sprite onAllocatePoolItem() {
        return new Sprite(AndEngineSimpleGame.player.getX(),AndEngineSimpleGame.player.getY(), mTextureRegion.deepCopy());
    }

    /** Called when a projectile is sent to the pool */
    protected void onHandleRecycleItem(final Sprite projectile) {
        projectile.clearEntityModifiers();
        projectile.clearUpdateHandlers();
        projectile.setVisible(false);
        projectile.detachSelf();
        projectile.reset();
    }
}

here’s an explanation for what’s going on, the class constructor takes texture region for the object you want [in our case it’ll be our mProjectileTextureRegion].
onAllocatePoolItem() is called when we need to create a new projectile sprite,  so we use our mTextureRegion and set the position as the player’s position [don’t forget to change the modifier of the player’s sprite to static]
onHandleRecycleItem() is called when you want to recycle an item [return a projectile to the pool], just clear everything and let it detach itself from the main scene .. pretty straight forward

now , let’s use that shall we ?

Using the pool

in our BaseGameActivity [AndEngineSimpleGame.java] declare this

ProjectilesPool pPool;

[don’t read the fast or you’ll get the image of a yellow pool]
initialize it in onLoadResources()

pPool = new ProjectilesPool(mProjectileTextureRegion);

let’s go to our shootProjectile() method and make a use of our new pool

Sprite projectile;
// position the projectile on the player
projectile = pPool.obtainPoolItem();

This will get us a recycled projectile to use [save the planet !]

let’s modify our detect IUpdateHandler to make a use of the pool too, whenever you see a removeSprite() method call for the projectiles, replace it with

pPool.recyclePoolItem(_projectile);
projectiles.remove();

and you are all set, launch and enjoy your environment friendly game

Now what ?
now you go ahead and create another pool for the targets to use, it’s basically the same thing so you should be able to do it yourself, you’ll notice that you won’t be using the removeSprite() method anymore , so just remove it
but if you had problems with it, you can download the whole project’s source code
for any questions , drop a comment [comments gives me that nice feeling inside :P]

You can also continue with the next part of the tutorial’s series here