Android AndEngine:sprite.detachSelf（）不会删除该精灵

我正在制作小气球游戏。气球随机弹出，一会儿就消失了。当我点击它们时，我想让它们消失，并显示+1而不是气球。当我单击气球时，我想取消气球精灵的附加。 我的问题是，当我在代码中调用sprite.detachSelf（）时，该精灵只是消失了，但实际上该精灵没有被移除。它只会变得看不见。当我再次单击该位置时，将显示引出序号，即使在引出序号消失后，也会显示+1。这意味着我认为气球没有正确脱钩

这是我的密码：

@Override
protected Scene onCreateScene() {

    //this.mEngine.registerUpdateHandler(new FPSLogger());
    scene = new Scene();

    backgroundSprite = new Sprite(0, 0, this.mBackgroundTextureRegion,
            getVertexBufferObjectManager());
    backgroundSprite.setSize(CAMERA_WIDTH, CAMERA_HEIGHT);
    scene.attachChild(backgroundSprite);
    scene.unregisterTouchArea(backgroundSprite);

    text = new Text(0, 0, font, "Score : 00",
            getVertexBufferObjectManager());
    scene.attachChild(text);

    textTime = new Text(displayMetrics.widthPixels - 220, 0, font,
            "00 : 60", getVertexBufferObjectManager());
    scene.attachChild(textTime);

    timer = new TimerClock(1, new TimerClock.ITimerCallback() {
        TimerClock t = timer;
        public void onTick() {
            System.out.println("timer inside");
            if (time > 0) {
                time = time - 1;
                System.out.println("timer inside : " + time);
                scene.detachChild(textTime);
                textTime = new Text(displayMetrics.widthPixels - 220, 0,
                        font, "00 : " + time,
                        getVertexBufferObjectManager());
                if (time < 10) {
                    textTime.setColor(1, 0, 0);
                }
                scene.attachChild(textTime);
                deleteSpriteSpawnTimeHandler(sprite);

            }
            else{
                scene.unregisterUpdateHandler(this.t);
            }

        }
    });
    this.mEngine.registerUpdateHandler(timer);

    createSpriteSpawnTimeHandler();
    return scene;
}

private void deleteSpriteSpawnTimeHandler(final IEntity ball) {
    TimerHandler spriteTimerHandler1;
    final Engine e = mEngine;
    this.getEngine().registerUpdateHandler(
            spriteTimerHandler1 = new TimerHandler(0.5f, true,
                    new ITimerCallback() {
                        @Override
                        public void onTimePassed(
                                final TimerHandler spriteTimerHandler1) {
                            spriteTimerHandler1.reset();

                            deleteSprite(ball);
                        }
                    }));
}

private void gameOverSpawnTimeHandler() {
    TimerHandler spriteTimerHandler1;
    final Engine e = mEngine;
    this.getEngine().registerUpdateHandler(
            spriteTimerHandler1 = new TimerHandler(60, true,
                    new ITimerCallback() {


                        @Override
                        public void onTimePassed(
                                final TimerHandler spriteTimerHandler1) {
                            spriteTimerHandler1.reset();

                            timeDue = 0;
                            scene.detachChild(textComment);
                            textComment = new Text(CAMERA_WIDTH / 2 - 100,
                                    CAMERA_HEIGHT / 2, font,
                                    "Game Over...!!!",
                                    getVertexBufferObjectManager());
                            textComment.setColor(1.0f, 0.0f, 0.0f);
                            scene.attachChild(textComment);

                            SharedPreferences myPrefs = getApplicationContext().getSharedPreferences("myPrefs",
                                            MODE_WORLD_READABLE);
                            SharedPreferences.Editor prefsEditor = myPrefs.edit();

                            String score1 = myPrefs.getString("SCORE1", "0");
                            String score2 = myPrefs.getString("SCORE2", "0");

                            int scoreInt1 = Integer.parseInt(score1);
                            int scoreInt2 = Integer.parseInt(score2);

                            System.out.println("session in" + score1 + " "
                                    + score2);
                            currScore = totalScore;

                            if (currScore > scoreInt1 && currScore > scoreInt2) {
                                prefsEditor.clear();
                                prefsEditor.commit();
                                prefsEditor.putString("SCORE1", String.valueOf(currScore));
                                prefsEditor.putString("SCORE2", String.valueOf(scoreInt1));
                                prefsEditor.commit();
                            } else if (currScore < scoreInt1 && currScore > scoreInt2) {
                                prefsEditor.clear();
                                prefsEditor.commit();
                                prefsEditor.putString("SCORE1", String.valueOf(scoreInt1));
                                prefsEditor.putString("SCORE2", String.valueOf(currScore));
                                prefsEditor.commit();
                            } else {

                            }

                        }
                    }));
}

private void createSpriteSpawnTimeHandler() {
    TimerHandler spriteTimerHandler;

    final Engine e = mEngine;
    this.getEngine().registerUpdateHandler(
            spriteTimerHandler = new TimerHandler(0.75f, true,
                    new ITimerCallback() {
                        @Override
                        public void onTimePassed(
                                final TimerHandler spriteTimerHandler) {
                            spriteTimerHandler.reset();

//                              scene.detachChild(backgroundSprite);
//                              scene.attachChild(backgroundSprite);

                            // Random Position Generator
                            final float xPos = MathUtils.random(50.0f,
                                    (CAMERA_WIDTH - 50.0f));
                            final float yPos = MathUtils.random(75.0f,
                                    (CAMERA_HEIGHT - 75.0f));
                            gameOverSpawnTimeHandler();
                            if (timeDue > 0) {
                                createSprite(xPos, yPos);
                            }else{
                                //scene.unregisterUpdateHandler(spriteTimerHandler);
                            }
                        }
                    }));
}

private void createSpriteTextSpawnTimeHandler() {
    TimerHandler spriteTimerHandler;

    final Engine e = mEngine;
    this.getEngine().registerUpdateHandler(
            spriteTimerHandler = new TimerHandler(mEffectSpawnDelay, true,
                    new ITimerCallback() {
                        @Override
                        public void onTimePassed(
                                final TimerHandler spriteTimerHandler) {
                            spriteTimerHandler.reset();

                            if (totalScore > 50 && totalScore < 60) {
                                textComment = new Text(150, 100, font,
                                        "Ohhhh...you are doing good.",
                                        getVertexBufferObjectManager());
                                textComment.setColor(1.0f, 0.0f, 0.0f);
                                scene.attachChild(textComment);
                            }
                            deleteSpriteSpawnTimeHandler(textComment);

                            // e.getScene().detachChild(backgroundSprite);
                            // e.getScene().attachChild(backgroundSprite);
                        }
                    }));
}

private void createSprite(final float pX, final float pY) {

    sprite = new Sprite(pX, pY, this.mrball, getVertexBufferObjectManager()) {
        Engine e = mEngine;
        TextureRegion gball = mgball;
        float x = pX;
        float y = pY;
        private int score = totalScore;
        private Text textComment;;

        @Override
        public boolean onAreaTouched(
                org.andengine.input.touch.TouchEvent pSceneTouchEvent,
                float pTouchAreaLocalX, float pTouchAreaLocalY) {

            if (pSceneTouchEvent.getAction() == TouchEvent.ACTION_DOWN) {
                this.e.getScene().detachChild(this);
                if (timeDue > 0) {
                    mBrushDrawingSound.play();
                    totalScore = totalScore + 1;
                    String score = "Score : " + totalScore;
                    scene.detachChild(text);
                    text = new Text(0, 0, font, score,
                            getVertexBufferObjectManager());
                    scene.attachChild(text);

                    //sprite.detachSelf();
                    createSpriteTextSpawnTimeHandler();

                    textScorePlus = new Text(x, y, font, "+1",
                            getVertexBufferObjectManager());
                    scene.attachChild(textScorePlus);
                    scene.unregisterTouchArea(textScorePlus);

                    deleteSpriteSpawnTimeHandler(textScorePlus);
                }
            } else if (pSceneTouchEvent.getAction() == TouchEvent.ACTION_UP) {
            }

            // e.getScene().unregisterTouchArea(sprite);
            return true;
        }
    };
    spriteBalloon.add(sprite);
    sprite.setSize(100, 100);
    sprite.setAlpha(0.8f);
    Random randomGenerator = new Random();
    red = randomGenerator.nextInt(255);
    green = randomGenerator.nextInt(255);
    blue = randomGenerator.nextInt(255);
    sprite.setColor(red, green, blue);
    scene.registerTouchArea(sprite);
    scene.attachChild(sprite);
    deleteSpriteSpawnTimeHandler(sprite);
}

private void deleteSprite(IEntity pBall) {
    IEntity gball = pBall;
    scene.detachChild(gball);;
}

@覆盖
受保护的场景onCreateSecene（）{
//this.mEngine.registerUpdateHandler（新的FPSLogger（））；
场景=新场景（）；
backgroundSprite=新Sprite（0,0，this.mBackgroundTextureRegion，
getVertexBufferObjectManager（））；
backgroundSprite.setSize（摄像头宽度、摄像头高度）；
场景：attachChild（背景精灵）；
场景。未注册触摸区域（背景精灵）；
text=新文本（0，0，字体，“分数：00”，
getVertexBufferObjectManager（））；
场景。附件（文本）；
textTime=新文本（displayMetrics.widthPixels-220，0，字体，
“00:60”，getVertexBufferObjectManager（）；
scene.attachChild（textTime）；
timer=new TimerClock（1，new TimerClock.ITimerCallback（）{
定时器锁t=定时器；
公共空间{
System.out.println（“内部计时器”）；
如果（时间>0）{
时间=时间-1；
System.out.println（“计时器内部：+时间”）；
scene.detachChild（textTime）；
textTime=新文本（displayMetrics.widthPixels-220,0，
字体，“00:+时间，
getVertexBufferObjectManager（））；
如果（时间<10）{
setColor（1,0,0）；
}
scene.attachChild（textTime）；
删除SpritesPawnTimeHandler（sprite）；
}
否则{
unregisterUpdateHandler（this.t）；
}
}
});
this.mEngine.registerUpdateHandler（计时器）；
createSpriteSpawnTimeHandler（）；
返回场景；
}
私有void deleteSpriteSpawnTimeHandler（最终用户球）{
TimerHandler spriteTimerHandler 1；
最终发动机e=发动机；
此.getEngine（）.registerUpdateHandler(
SpriteTimerHandler 1=新的时间Handler（0.5f，真，
新ITimerCallback（）{
@凌驾
已通过公共无效时间(
最终时间指示器SPRITETIMERHANDLER 1）{
spriteTimerHandler1.reset（）；
删除雪碧（球）；
}
}));
}
私有void gameovershawntimehandler（）{
TimerHandler spriteTimerHandler 1；
最终发动机e=发动机；
此.getEngine（）.registerUpdateHandler(
spriteTimerHandler 1=新的TimerHandler（60，真，
新ITimerCallback（）{
@凌驾
已通过公共无效时间(
最终时间指示器SPRITETIMERHANDLER 1）{
spriteTimerHandler1.reset（）；
timeDue=0；
scene.detachChild（textComment）；
Text注释=新文本（摄像头宽度/2-100，
摄像头高度/2，字体，
“游戏结束了…”，
getVertexBufferObjectManager（））；
setColor（1.0f，0.0f，0.0f）；
scene.attachChild（文本评论）；
SharedReferences myPrefs=getApplicationContext（）。GetSharedReferences（“myPrefs”，
模式（世界可读）；
SharedReferences.Editor prefsEditor=myPrefs.edit（）；
String score1=myPrefs.getString（“score1”、“0”）；
String score2=myPrefs.getString（“score2”，“0”）；
int scoreInt1=整数.parseInt（score1）；
int scoreInt2=Integer.parseInt（score2）；
System.out.println（“会话输入”+score1+“”
+得分2分）；
currScore=总分；
如果（currScore>scoreInt1&&currScore>scoreInt2）{
prefsEditor.clear（）；
提交（）；
prefsEditor.putString（“SCORE1”，String.valueOf（currScore））；
prefsEditor.putString（“SCORE2”，String.valueOf（scoreInt1））；
提交（）；
}否则如果（currScorescoreInt2）{
prefsEditor.clear（）；
提交（）；
prefsEditor.putString（“SCORE1”，String.valueOf（scoreInt1））；
prefsEditor.putString（“SCORE2”，String.valueOf（currScore））；
提交（）；
}否则{
}
}
}));
}
私有void createSpriteSpawnTimeHandler（）{
时间指示器spriteTimerHandler；
最终发动机e=发动机；
此.getEngine（）.registerUpdateHandler(
spriteTimerHandler=新的时间Handler（0.75f，真，
新ITimerCallback（）{
@凌驾
已通过公共无效时间(
最终时间指示器（spriteTimerHandler）{