Java Libgdx |参与者操作会导致某些设备出现口吃/冻结？

我的比赛快结束了。我面临的唯一问题是性能问题。我的游戏在我的droid turbo 1和2以及galaxy note 3上运行得非常完美。问题是，在我的verizon ellispis上，它会冻结很短一段时间（就像口吃一样）。但它的速度是每分钟60帧。我有理由相信这是因为演员的行为。我的游戏有8个敌人（像飞鸟中的烟斗）叫做拦截器。这些拦截器具有旋转动作、移动到动作和一个自定义动作（gapSizeAction），该动作可更改其间的空间。当阻挡者从游戏中移除时，口吃就消失了。我将在下面链接相关代码。谢谢

此代码的工作方式是有3个延迟操作。每次动作开始时，都会导致拦截器随机移动和/或旋转。创建编队。操作运行后，它们设置一个随机持续时间，然后重新启动。这些计时器在create方法中初始化一次。因此，您需要查看的唯一代码是操作本身。我觉得没有任何优化，但我可能错了。谢谢你的时间！我知道它有很多代码，所以只需记住每个拦截器动作的设置就可以了

 private void createDelayActions() {

    //Moving RunnableAction
    RunnableAction runnableAction_moving = Actions.run(new Runnable() {
        @Override
        public void run() {
            delayAction_moving.setDuration(Tools.generateFloat(Config.minMovementCooldown, Config.maxMovementCooldown));
            delayAction_moving.restart();

            if (!swinging && !circlifying && !moving && !spinning && !initializing) {
                float maxDuration = 0;
                for (Blocker blocker : blockers) {
                    float gap = Tools.generateFloat(Config.minBlockerGap, Config.maxBlockerGap);
                    float y = Tools.generateFloat(Config.minBlockerY, Config.maxBlockerY - gap);
                    float duration = Tools.generateFloat(Config.minBlockerYDuration, Config.maxBlockerYDuration);
                    blocker.addAction(Actions.after(Actions.moveTo(blocker.getX(), y, duration, Config.blockerInterpolation)));
                    blocker.addAction(GapSizeAction.getGapSizeAction(gap, duration));

                    if (duration > maxDuration) {
                        maxDuration = duration;
                    }
                }

                RunnableAction action = Actions.run(new Runnable() {
                    @Override
                    public void run() {
                        moving = false;
                    }
                });
                stage.addAction(Actions.delay(maxDuration, action));
                moving = true;
            }

            System.out.println("runnableAction_moving");
        }
    });
    delayAction_moving = Actions.delay(2, runnableAction_moving);

    //Spinning RunnableAction
    RunnableAction runnableAction_spinning = Actions.run(new Runnable() {
        @Override
        public void run() {

            delayAction_spinning.setDuration(Tools.generateFloat(Config.minSpinCooldown, Config.maxSpinCooldown));
            delayAction_spinning.restart();

            if (!swinging && !circlifying && !moving && !spinning && !initializing) {
                float spins = Tools.generateFloat(Config.minSpinRotations, Config.maxSpinRotations);

                float duration;

                if (spins < 0) { //With player, clockwise
                    duration = Math.abs(spins * 10); /* The more you multiply @spins by, the 'slower' blocker spins */
                    duration += Tools.generateFloat(-(duration / 3), duration / 3);
                } else { //Against player, counter-clockwise
                    duration = Math.abs(spins * 20); /* The more you multiply @spins by, the 'slower' blocker spins */
                    duration += Tools.generateFloat(-(duration / 3), duration / 3);
                }

                for (Blocker blocker : blockers) {
                    blocker.addAction(Actions.rotateBy(360 * spins, duration, Config.blockerInterpolation));
                }

                RunnableAction action = Actions.run(new Runnable() {
                    @Override
                    public void run() {
                        spinning = false;
                    }
                });
                stage.addAction(Actions.delay(duration, action));
                spinning = true;
            }

            System.out.println("runnableAction_spinning");
        }
    });
    delayAction_spinning = Actions.delay(2, runnableAction_spinning);

    //Swinging RunnableAction
    RunnableAction runnableAction_swinging = Actions.run(new Runnable() {
        @Override
        public void run() {
            delayAction_swinging.setDuration(Tools.generateFloat(Config.minSwingCooldown, Config.maxSwingCooldown));
            delayAction_swinging.restart();

            if (!swinging && !circlifying && !moving && !spinning && !initializing) {

                float spins = Tools.generateFloat(Config.minSpinRotations, Config.maxSpinRotations);
                float duration = Math.abs(spins * 3); /* The more you multiply @spins by, the faster blocker spins */
                duration += Tools.generateFloat(-(duration / 3), duration / 3);

                int rotation = Tools.generateInt(1, 359);
                int type = Tools.generateInt(0, 1);

                /*
                There are two types of swings :
                    -All blockers pile ontop of each other (#0)
                    -Blockers pile every 90 degrees, 4 piles (#1)
                    The type generates the numbers 0 or 1
                */
                float y = Tools.generateFloat(Config.minBlockerY, Config.maxBlockerY);
                float gap = Tools.generateFloat(Config.minBlockerGap, Config.maxBlockerGap);

                for (Blocker blocker : blockers) {

                    Action seqAction = Actions.sequence(
                            GapSizeAction.getGapSizeAction(gap, 2f),
                            Actions.moveTo(blocker.getX(), y, 2f, Config.blockerInterpolation),
                            Actions.sequence(Actions.rotateTo(rotation, 2f, Config.blockerInterpolation), Actions.rotateBy(360 * spins, duration, Config.blockerInterpolation))
                    );

                    blocker.addAction(seqAction);

                    if (type == 1) { //Cause it to increment rotation (by 90 so every quarter) if type == 1 (if not, do original swing (all blockers ontop of each other))
                        rotation += 90;

                        while (rotation > 360) {
                            rotation -= 360;
                        }
                    }
                }

                RunnableAction action = Actions.run(new Runnable() {
                    @Override
                    public void run() {
                        swinging = false;
                        circlifyBlockers(4f);
                    }
                });
                stage.addAction(Actions.delay(duration + 6, action));

                swinging = true;
            }
            System.out.println("runnableAction_swinging");
        }
    });
    delayAction_swinging = Actions.delay(2, runnableAction_swinging);

}

private void circlifyBlockers(float duration) {
    if (blockers.size <= 0) {
        return;
    }
    if (circlifying) {
        return;
    }
    float gap = Tools.generateFloat(Config.minBlockerGap, Config.maxBlockerGap);
    float y = Tools.generateFloat(Config.minBlockerY, Config.maxBlockerY - gap);

    float spacing = 360 / blockers.size;
    float counter = spacing;
    for (Blocker blocker : blockers) {
        Action action = blockerHasAction(blocker, Actions.rotateBy(0, 0));
        if (action != null) { //Then blocker already has spinning action, so remove it before adding new spinning action
            blocker.removeAction(action);
        }
        action = blockerHasAction(blocker, Actions.rotateTo(0, 0));
        if (action != null) { //Then blocker already has spinning action, so remove it before adding new spinning action
            blocker.removeAction(action);
        }
        action = blockerHasAction(blocker, GapSizeAction.getGapSizeAction(0, 0));
        if (action != null) { //Then blocker already has spinning action, so remove it before adding new spinning action
            blocker.removeAction(action);
        }
        action = blockerHasAction(blocker, Actions.moveTo(0, 0));
        if (action != null) { //Then blocker already has spinning action, so remove it before adding new spinning action
            blocker.removeAction(action);
        }
        blocker.addAction(Actions.sequence(Actions.parallel(Actions.moveTo(blocker.getX(), y, duration, Config.blockerInterpolation), GapSizeAction.getGapSizeAction(gap, duration)), Actions.rotateTo(counter, duration, Config.blockerInterpolation)));
        counter += spacing;
    }

    RunnableAction action = Actions.run(new Runnable() {
        @Override
        public void run() {
            circlifying = false;
        }
    });
    stage.addAction(Actions.delay(duration + 6, action));

    circlifying = true;

    System.out.println("Circlify");
}

private void circlifyBlockers(float duration, float y, float gap) {
    if (blockers.size <= 0) {
        return;
    }

    float spacing = 360 / blockers.size;
    float counter = spacing;
    for (Blocker blocker : blockers) {
        Action action = blockerHasAction(blocker, Actions.rotateBy(0, 0));
        if (action != null) { //Then blocker already has spinning action, so remove it before adding new spinning action
            return;
        }
        action = blockerHasAction(blocker, Actions.rotateTo(0, 0));
        if (action != null) { //Then blocker already has spinning action, so remove it before adding new spinning action
            return;
        }
        blocker.addAction(Actions.sequence(Actions.parallel(Actions.moveTo(blocker.getX(), y, duration, Config.blockerInterpolation), GapSizeAction.getGapSizeAction(gap, duration)), Actions.rotateTo(counter, duration, Config.blockerInterpolation)));
        counter += spacing;
    }

    System.out.println("Circlify");
}

 private Action blockerHasAction(Blocker blocker, Action hasAction) {
    for (Action action : blocker.getActions()) {
        if (action.getClass().equals(hasAction.getClass())) {
            return action;
        }
    }
    return null;
}

private void createDelayActions（）{
//移动过滤
RunnableAction RunnableAction\u moving=Actions.run（new Runnable（）{
@凌驾
公开募捐{
delayAction_moving.setDuration（Tools.generateFloat（Config.minMovementCooldown，Config.maxmmovementcooldown））；
delayAction_moving.restart（）；
如果（！摆动&&！旋转&&！移动&&！旋转&&！初始化）{
float maxDuration=0；
用于（拦截器拦截器：拦截器）{
float gap=Tools.generateFloat（Config.minBlockerGap，Config.maxBlockerGap）；
float y=Tools.generateFloat（Config.minBlockerY、Config.maxBlockerY-gap）；
float duration=Tools.generateFloat（Config.minBlockerYDuration，Config.maxBlockerYDuration）；
addAction（Actions.after（Actions.moveTo（blocker.getX（），y，duration，Config.blockerInterpolation））；
blocker.addAction（GapSizeAction.getGapSizeAction（间隙，持续时间））；
如果（持续时间>最大持续时间）{
最大持续时间=持续时间；
}
}
RunnableAction action=Actions.run（新的Runnable（）{
@凌驾
公开募捐{
移动=假；
}
});
stage.addAction（Actions.delay（maxDuration，action））；
移动=真；
}
System.out.println（“runnableAction_moving”）；
}
});
delayAction\u moving=Actions.delay（2，runnableAction\u moving）；
//纺纱脱色
RunnableAction RunnableAction\u spining=Actions.run（new Runnable（）{
@凌驾
公开募捐{
delayAction_spining.setDuration（Tools.generateFloat（Config.minSpinCooldown，Config.maxspincoldown））；
delayAction_spining.restart（）；
如果（！摆动&&！旋转&&！移动&&！旋转&&！初始化）{
float spins=Tools.generateFloat（Config.minSpinRotations，Config.maxSpinRotations）；
浮动持续时间；
如果（旋转<0）{//与播放器顺时针旋转
duration=Math.abs（旋转*10）；/*将@spins乘以越多，拦截器旋转越慢*/
持续时间+=工具.generateFloat（-（持续时间/3），持续时间/3）；
}否则{//逆时针方向对着玩家
duration=Math.abs（旋转*20）；/*将@spins乘以越多，拦截器旋转的速度就越慢*/
持续时间+=工具.generateFloat（-（持续时间/3），持续时间/3）；
}
用于（拦截器拦截器：拦截器）{
blocker.addAction（Actions.rotateBy（360*旋转，持续时间，配置blockerInterpolation））；
}
RunnableAction action=Actions.run（新的Runnable（）{
@凌驾
公开募捐{
旋转=假；
}
});
阶段。添加动作（动作。延迟（持续时间，动作））；
旋转=真；
}
System.out.println（“runnableAction_spining”）；
}
});
delayAction_spining=动作。延迟（2，runnableAction_spining）；
//摆动式脱色
RunnableAction RunnableAction\u swing=Actions.run（new Runnable（）{
@凌驾
公开募捐{
delayAction_swing.setDuration（Tools.generateFloat（Config.minSwingCooldown，Config.maxSwingCooldown））；
delayAction_swing.restart（）；
如果（！摆动&&！旋转&&！移动&&！旋转&&！初始化）{
float spins=Tools.generateFloat（Config.minSpinRotations，Config.maxSpinRotations）；
浮动持续时间=Math.abs（旋转*3）；/*将@spins乘以越多，拦截器旋转越快*/
持续时间+=工具.generateFloat（-（持续时间/3），持续时间/3）；
int-rotation=Tools.generateInt（1359）；
int type=Tools.generateInt（0,1）；
/*
有两种类型的摆动：
-所有拦截器相互堆叠（#0）
-拦截器每90度堆放一次，4堆（#1）
该类型生成数字0或1
*/
float y=Tools.generateFloat（Config.minBlockerY、Config.maxBlockerY）；
float gap=Tools.generateFloat（Config.minBlockerGap，Config.maxBlockerGap）；
用于（拦截器拦截器：拦截器）{
行动