Java 创建可滚动的级别选择器（AndEngine）

我的水平选择器有问题。我正在使用我在这个论坛的教程中找到的代码，但它工作不正确

事实上，我有两个场景我正在使用当用户混搭播放我设置引擎到第二个场景，然后用户可以滚动通过水平

然后，当用户按下后退按钮时，我通过在离开前保存位置，然后使用camer.setCenter（x，y）将相机设置回其初始位置

一旦用户返回到leve selector场景，它就不会正确地担心了。当用户滚动时，它会从屏幕上滚下来，并且不能正常工作

这是我的密码。如果有人有更好的方法，请随时与我分享

   @Override
            public boolean onSceneTouchEvent(Scene pScene, TouchEvent pSceneTouchEvent) {

                    // TODO Auto-generated method stub
                    clickDetector.onTouchEvent(pSceneTouchEvent);
                    surfaceScrollDetector.onTouchEvent(pSceneTouchEvent);

           return true;
            }









                    @Override
                    public void onScrollStarted(ScrollDetector pScollDetector,
                                    int pPointerID, float pDistanceX, float pDistanceY) {
                             // TODO Auto-generated method stub
                distanceX = 0;

                    }




                    @Override
                    public void onScroll(ScrollDetector pScollDetector, int pPointerID,
                                    float pDistanceX, float pDistanceY) {
                            // TODO Auto-generated method stub

                            camera.offsetCenter(-pDistanceX, 0);

                distanceX += pDistanceX;
                    }




                    @Override
                    public void onScrollFinished(ScrollDetector pScollDetector,
                                    int pPointerID, float pDistanceX, float pDistanceY) {
                             if ((distanceX > TURN_PAGE_DISTANCE) && (page > 0))
                 {

                         page--;
                         camera.offsetCenter(distanceX - CAMERA_WIDTH, 0);
                 }
                 else if ((distanceX < -TURN_PAGE_DISTANCE) && (page < LEVEL_PAGES - 1))
                 {

                         page++;
                         camera.offsetCenter(distanceX + CAMERA_WIDTH, 0);
                 }
                 else
                 {

                         camera.offsetCenter(distanceX, 0);
                 }

                    }




                    @Override
                    public void onClick(ClickDetector pClickDetector, int pPointerID,
                                    float pSceneX, float pSceneY) {
                             //loadLeve(levelClicked);
                    }

                     private void createHUD()
                    {
                            // 不用考虑层
                            hud = new HUD();
                            Rectangle hudBox = new Rectangle(20, 700, 80, 80, getVertexBufferObjectManager())
                            {
                                    @Override
                                    public boolean onAreaTouched(TouchEvent pSceneTouchEvent, float pTouchAreaLocalX,
                                                    float pTouchAreaLocalY)
                                    {
                                            // TODO Auto-generated method stub
                                            if (pSceneTouchEvent.isActionUp())
                                            {
                                                    runOnUiThread(new Runnable()
                                                    {
                                                            @Override
                                                            public void run()
                                                            {
                                                                    // TODO Auto-generated method stub
                                                                    Toast.makeText(Menu.this, "BACK", Toast.LENGTH_SHORT).show();
                                                            }
                                                    });
                                            }

                                            return true;
                                    }
                            };
                            hudBox.setColor(Color.RED);
                            hud.attachChild(hudBox);
                            hud.registerTouchArea(hudBox);
                            camera.setHUD(hud);
                    }

    @Override
    public boolean onKeyDown(final int pKeyCode, final KeyEvent pEvent) {
                  if (pKeyCode == KeyEvent.KEYCODE_BACK
                            && pEvent.getAction() == KeyEvent.ACTION_DOWN
                            ) {


                                    if(level_scene){
                                      level_scene = false;
                                      camera.setCenter(camera_x, camera_y);
                                  mEngine.setScene(MainMenuScene);
                                    }else{
                                            finish();
                                    }
                                     return true;

                            }
                               return super.onKeyDown(pKeyCode, pEvent);




    }

    private void createLevelBoxes()
    {


            // 计算行间距
            int spaceBetweenRaws = (CAMERA_HEIGHT / LEVEL_ROWS_PER_SCREEN) - LEVEL_PADDING;
            // 计算列间距
            int spaceBetweenColumns = (CAMERA_WIDTH / LEVEL_COLUMNS_PER_SCREEN) - LEVEL_PADDING;

            int level = 0;

            int boxX = LEVEL_PADDING;
            int boxY = LEVEL_PADDING;

            for (int i=0; i<LEVEL_PAGES; i++)
            {
                    int startX = i * CAMERA_WIDTH;

                    for (int j=0; j<LEVEL_ROWS_PER_SCREEN; j++)
                    {
                            for (int k=0; k<LEVEL_COLUMNS_PER_SCREEN; k++)
                            {
                                    final int levelToLoad = level;
                               box = new Sprite(startX + boxX, boxY, 90,70,this.levelIcon,this.getVertexBufferObjectManager())
                                    {
                                            @Override
                                            public boolean onAreaTouched(TouchEvent pSceneTouchEvent, float pTouchAreaLocalX,
                                                            float pTouchAreaLocalY)
                                            {

                                                    // TODO Auto-generated method stub

                                                             levelClicked = levelToLoad;
                                                           if(levelClicked <= maxLevelReached){

                                                               Intent intent = new Intent(Menu.this, GameLevel.class);

                                                            intent.putExtra("level", levelClicked);
                                                            startActivity(intent);
                                                            woodClick.play();
                                                           }
                                                    return false;
                                            }
                                    };


                                    if (level <= maxLevelReached)
                                    {

                                    }
                                    else
                                    {
                                      box.setColor(0.4117647f, 0.4117647f,0.4117647f);      
                                    }

                                    levelScene.attachChild(box);
                                    levelScene.registerTouchArea(box);
                                    int textOffX = 0;
                                    if (level < 10)
                                    {
                                            textOffX = 28;
                                    }
                                    else
                                    {
                                            textOffX = 20;
                                    }
                                    box.attachChild(new Text(textOffX, 20, font, String.valueOf(level + 1),this.getVertexBufferObjectManager()));


                                    level++;
                                    boxX += spaceBetweenColumns + LEVEL_PADDING;
                                    if (level > LEVELS)
                                    {
                                            break;
                                    }
                            }
                            if (level > LEVELS)
                            {
                                    break;
                            }


                            boxY += spaceBetweenRaws + LEVEL_PADDING;
                            boxX = LEVEL_PADDING;
                    }

                    boxY = LEVEL_PADDING;

            }
    }

@覆盖
公共布尔onSceneTouchEvent（场景pScene、触摸事件pSceneTouchEvent）{
//TODO自动生成的方法存根
单击Detector.onTouchEvent（pSceneTouchEvent）；
表面滚动检测器。onTouchEvent（pSceneTouchEvent）；
返回true；
}
@凌驾
公共无效onScrollStarted（滚动检测器pScollDetector，
int pPointerID、浮点pDistanceX、浮点pDistanceY）{
//TODO自动生成的方法存根
距离x=0；
}
@凌驾
公共无效onScroll（滚动检测器pScollDetector、int pPointerID、，
浮动pDistanceX，浮动pDistanceY）{
//TODO自动生成的方法存根
摄像机偏移中心（-pDistanceX，0）；
距离X+=pDistanceX；
}
@凌驾
公共空间已完成（滚动检测器PSCOLLDECTOR，
int pPointerID、浮点pDistanceX、浮点pDistanceY）{
如果（（距离X>翻页距离）和（&（翻页>0））
{
第页--；
摄像机偏移中心（距离X-摄像机宽度，0）；
}
否则如果（（距离X<-翻页距离）和（（翻页<水平页数-1））
{
page++；
摄像机偏移中心（距离X+摄像机宽度，0）；
}
其他的
{
摄像机偏移中心（距离X，0）；
}
}
@凌驾
单击公共无效（单击检测器pClickDetector、int-pPointerID、，
浮动pSceneX，浮动pSceneY）{
//loadLeve（levelClicked）；
}
私有void createHUD（）
{
// 不用考虑层
hud=新的hud（）；
矩形hudBox=新矩形（20700,80,80，getVertexBufferObjectManager（））
{
@凌驾
公共布尔onreatouched（TouchEvent pSceneTouchEvent、float pTouchAreaLocalX、，
浮动（本地）
{
//TODO自动生成的方法存根
if（pSceneTouchEvent.isActionUp（））
{
runOnUiThread（新的Runnable（）
{
@凌驾
公开募捐
{
//TODO自动生成的方法存根
Toast.makeText（Menu.this，“BACK”，Toast.LENGTH_SHORT）.show（）；
}
});
}
返回true；
}
};
设置颜色（颜色为红色）；
hud.附件（hud盒）；
hud.注册图（hudBox）；
摄像头。设置抬头显示器（hud）；
}
@凌驾
公共布尔onKeyDown（final int-pKeyCode，final-KeyEvent-pEvent）{
如果（pKeyCode==KeyEvent.KEYCODE_BACK
&&pEvent.getAction（）==KeyEvent.ACTION\u向下
) {
if（场景层级）{
level_场景=假；
摄像机设置中心（摄像机x、摄像机y）；
mEngine.setScene（主MenuScene）；
}否则{
完成（）；
}
返回true；
}
返回super.onKeyDown（pKeyCode，pEvent）；
}
私有void CreateLevelBox（）
{
// 计算行间距
int spaceBetweenRaws=（相机高度/每屏幕水平行）-水平填充；
// 计算列间距
int spaceBetweenColumns=（相机宽度/每屏幕的水平列）-水平填充；
智力水平=0；
int boxX=电平填充；
int boxY=水平面填充；
用于（int i）