Java 如何从cachedActions Libgdx继续序列/并行操作

我有一个clicklistener扩展类，它旨在缓存演员在触地期间的任何当前动作，并在触地触发时将其分配回。但是，它不适用于顺序或并行操作

public class MyClickListener extends ClickListener {

    public Actor actor;
    private final Array<Action> cachedActions = new Array<Action>();

    @Override
    public void touchUp(InputEvent event, float x, float y, int pointer, int button) {
        super.touchUp(event, x, y, pointer, button);
        actor = event.getListenerActor();
        actor.addAction(btnScaleBackActions());
        for(Action action:cachedActions)
        {
            //action.reset(); // i wants the actor to continue at where it stop
            action.setTarget(actor);
            action.setActor(actor);
            actor.addAction(action);
        }
        cachedActions.clear();
    }

    @Override
    public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
        if(pointer==0)
        {
            actor = event.getListenerActor();
            actor.setScale(0.9f);
            cachedActions.addAll(actor.getActions());
            actor.clearActions();
            return super.touchDown(event, x, y, pointer, button);
        }
        else
        {
            return false;
        }
    }

---

是否可以在myClickListener类停止的位置继续序列/并行操作？

来自池（如actions类）的操作的默认行为是在从参与者中删除它们时重新启动它们自己。实际上，重用这些实例并不安全，因为它们也已返回到池中，并且可能意外地连接到其他参与者

因此，在将它们从actor中删除之前，需要将它们的池设置为null

private static void clearPools (Array<Action> actions){
    for (Action action : actions){
        action.setPool(null);
        if (action instanceof ParallelAction) //SequenceActions are also ParallelActions
            clearPools(((ParallelAction)action).getActions()); 
        else if (action instanceof DelegateAction)
            ((DelegateAction)action).getAction().setPool(null);
    }
}

//And right before actor.clearActions();
clearPools(actor.getActions());

private static void clearPools（数组操作）{
for（操作：操作）{
action.setPool（null）；
if（action instanceof ParallelAction）//SequenceActions也是ParallelActions
clearPools（（（ParallelAction）action.getActions（））；
else if（DelegateAction的操作实例）
（（DelegateAction）action.getAction（）.setPool（null）；
}
}
//就在actor.clearActions（）之前；
ClearPool（actor.getActions（））；

然后，当您将它们添加回actor时，您需要将它们的池添加回actor，以便它们可以返回到操作池，并在以后重用，以避免GC搅动

private static void assignPools (Array<Action> actions){
    for (Action action : actions){
        action.setPool(Pools.get(action.getClass()));
        if (action instanceof ParallelAction)
            assignPools(((ParallelAction)action).getActions()); 
        else if (action instanceof DelegateAction){
            Action innerAction = ((DelegateAction)action).getAction();
            innerAction.setPool(Pools.get(innerAction.getClass()));
        }
    }
}

//And call it on your actor right after adding the actions back:
assignPools(actor.getActions);

私有静态池（数组操作）{
for（操作：操作）{
action.setPool（Pools.get（action.getClass（））；
if（并行操作的操作实例）
assignPools（（（ParallelAction）action.getActions（））；
else if（DelegateAction的操作实例）{
Action innerAction=（（DelegateAction）Action.getAction（）；
setPool（Pools.get（innerAction.getClass（））；
}
}
}
//并在添加动作后立即调用您的演员：
分配池（actor.getActions）；

这里有另一个想法。您可以将操作包装为一种新类型的可暂停操作，而不是处理删除和恢复操作，以及随后处理池问题

public class PausableAction extends DelegateAction {

    public static PausableAction pausable(Action wrappedAction){
        PausableAction action = Actions.action(PausableAction.class);
        action.setAction(wrappedAction);
        return action;
    }

    boolean paused = false;

    public void pause (){
        paused = true;
    }

    public void unpause (){
        paused = false;
    }

    protected boolean delegate (float delta){
        if (paused)
            return false;
        return action.act(delta);
    }

    public void restart () {
        super.restart();
        paused = false;
    }
}

现在，在获取操作时，请将其包装为可暂停的格式，例如：

btn1.addAction(PausableAction.pausable(Actions.scaleBy(1,1,3)));

并在需要时暂停/取消暂停操作，如：

//...
actor = event.getListenerActor();
actor.setScale(0.9f);
for (Action action : actor.getActions())
    if (action instanceof PausableAction)
        ((PausableAction)action).pause();
return super.touchDown(event, x, y, pointer, button);

---

非常感谢你！！非常好的解释，我从中学到了很多。再次感谢！！

//...
actor = event.getListenerActor();
actor.setScale(0.9f);
for (Action action : actor.getActions())
    if (action instanceof PausableAction)
        ((PausableAction)action).pause();
return super.touchDown(event, x, y, pointer, button);