How to pool child classes in LibGDX?

Question

I have a super class named Monster which implements Poolable. Then I got child classes which extends from the Monster class, but I can not figure out how I will use pool and maintain only one set of pool array.

Here is my current pool setup:

public class GameWorld {

    // Map
    private TmxMapLoader mapLoader;
    private TiledMap map;

    // Creatures
    private Player player;
    private final Array<Monster> activeMonsters = new Array<Monster>();
    private final Pool<Monster> monsterPool = new Pool<Monster>() {
        @Override
        protected Monster newObject() {
            return new Monster();
        }
    };

    public GameWorld(String path) {
        mapLoader = new TmxMapLoader();
        map = mapLoader.load(path);
        player = new Player();
        player.init("Player", this, new Vector2(5, 5));

        Monster firefox = Pools.obtain(Firefox.class);
        for (int i = 0; i <= 10; i++) {
            firefox.init("Firefox", this, new Vector2(8, 8));
            activeMonsters.add(firefox);
        }
    }

    public Player getPlayer() {
        return this.player;
    }

    public TiledMap getMap() {
        return map;
    }

    public Array<Monster> getMonsters() {
        Monster monster;
        int len = activeMonsters.size;
        for (int i = len; --i >= 0;) {
            monster = activeMonsters.get(i);
            if (monster.isVisible == false) {
                activeMonsters.removeIndex(i);
                monsterPool.free(monster);
            }
        }

        return this.activeMonsters;
    }
}

Answer 1

The short answer is that you can't return different subclasses from a Pool. Even if you used a static variable to pass parameters to newObject(), newObject() is only called when all of the pooled objects are already being used; meaning that you would never know which subclass you are getting when you obtained a pooled object.

Before continuing down this path, you may want to ask yourself, are you creating and destroying Monsters frequently enough to require pooling?

The next logical option is to create a MonsterFactory which contains a Pool for each monster type. You can create an enum for each monster type and pass it to a "public Monster createMonster(MonsterType type)" function. That way, you still have a uniform interface to generate your monsters and only the MonsterFactoryhas to keep track of the pools. Here's an example.

public class MonsterFactory{
    public Enum MonsterType{
      BIRD,
      RAT
    };

    private final Pool<Bird> birdPool = new Pool<Bird>() {
        @Override
        protected Bird newObject() {
            return new Bird();
        }
    };
    private final Pool<Rat> ratPool = new Pool<Rat>() {
        @Override
        protected Rat newObject() {
            return new Rat();
        }
    };

    public Monster createMonster(MonsterType monsterType){
       switch(monsterType){
         case BIRD:
            return birdPool.obtain();
         case RAT:
            return ratPool.obtain();
       }
    }

    //You must call destroyMonster whenever you are done with the monster or the pool will leak.
    public void destroyMonster(Monster monster){
       if(monster instanceof Bird){
         birdPool.free((Bird)monster);
       }
       else if(monster instanceof Rat){
         ratPool.free((Rat)monster);
       }
    }
}

However, if you are totally opposed to creating a Pool for each subclass, use Composition Over Inheritance. Using this method, you wouldn't use sub-classes for monsters, but you would instead plug-in their behaviors.

For example, if you want your monsters to move in various ways, say ZigZag and Straight Lines, you could have an IMovement interface member inside of your monster class that defines how the monster moves. You would then create them this way

IMovement zigZagMovement = new ZigZagMovement();
IMovement straightLineMovement = new StraightLineMovement();

public Monster createMonster(MonsterType monsterType){
    Monster newMonster = monsterPool.obtain();
    if(monsterType == MonsterType.Alligator){
       newMonster.movement = zigZagMovement ;
    }
    else if(monsterType == MonsterType.Zombie){
       newMonster.movement = straightLineMovement ;
    }
    return newMonster;
}

Then in your Monster class

public class Monster extends Actor
{
    public IMovement movement;

    public void act(float deltaTime){
       movement.move(deltaTime,this); //Updates the monster's movement
    }
}

Answer 2

If I'm not mistaken, you want to create a pool of different monster without creating many pools? If yes, just create a MonsterPool that extends Monster

public class MonsterPool<T extends Monster>  extends Pool<T>{

}

public MonsterFactory<T extends Monster> {

     Array<T> activeMonster = new Array<T>();
     MonsterPool<T> monsterPool = new MonsterPool< T>();

     public T obtainMonster () {
          return monsterPool .obtain();
     }

}

and use it like this.

new MonsterFactory<Slime.class>().obtain();
new MonsterFactory<Dinosaur.class>().obtain();