Question

I’m using a class that extends GenericPool to handle getting and recycling of sprites. What I’d like to do is have a method in that class to recycle after a certain duration. Something like:

public void recyleIn(Sprite sprite, float durationSeconds) {}

And there’s a handy/dandy DelayModifier that seems like the proper way to implement it. So we’d have something like the following:

public void recyleIn(MySprite mySprite, float durationSeconds) {
    mySprite.registerEntityModifier(
            new DelayModifier(
                    durationSeconds,

    new IEntityModifierListener() {

        @Override
        public void onModifierStarted(IModifier<IEntity> pModifier, IEntity pItem) {

        }

        @Override
        public void onModifierFinished(IModifier<IEntity> pModifier, IEntity pItem) {
            recycle(mySprite);
        }
    }

    ));
}

Now here’s the problem: I can’t call the recycle() method or do the recycling right there unless the Sprite is “final”. Ordinarily that wouldn’t be a problem, I’d just make a “final” deepcopy and use that. But in this case, making a copy defeats the original purpose of recycling in a pool. (E.g., if I’m just going to make a copy anyway, why bother to recycle and use pooling in the first place?)

Any ideas on the proper approach/model for this sort of thing? Thanks in advance.

---

UPDATE:

Umm.. I just realized I could just use the IEntity parameter in the onModifierFinished() method. (I’m used to ignoring those parameters for some reason.) So I could do something like this within the onModifierFinished():

recycle((MySprite) pItem);

I’d still be curious on anyone’s thoughts on the best approach, but I think I may have just missed the obvious here.

Answer 1

I’m going to go ahead and answer my own question to help those in this situation. The short answer is that it’s proper to use the IEntity parameter rather than an object outside it. The second issue I ran into when doing this is that I wanted to detach the IEntity from the scene in this method but, in AndEngine, it’s important that when an IEntity is detached from the scene it must happen in the UpdateThread–otherwise you have a chance of errors as the scene is drawing while something is being removed from it. The end result looks like this:

        @Override
        public void onModifierFinished(IModifier<IEntity> pModifier, final IEntity pItem) {
            pool.getContext().runOnUpdateThread(new Runnable() {
                @Override
                public void run() {
                    pItem.detachSelf();
                }
            });

        }

One other small but important point is the “final” modifier on the Ientity parameter–necessary so that it can be called within the run() thread.