android游戏设置界面设计 安卓游戏设计

是英雄就下100层游戏的设计与实现

摘要

此安卓项目为“是英雄就下100层”，背景设定为想挑战自我吗？有本事就下100层吧！跳跃层层障碍，人人都可以成为英雄，注意不能踩空。操作由屏幕触碰控制移动方向。系统的功能控制游戏中的角色不停的向下移动，保证角色不踩空使游戏计息，否则致使游戏失败。
主要实现类为PadelDao（英雄的设置）,DialogScore（排行榜得分对话框）,DialogSetting（自定义设置对话框）,GameScoreData（游戏的得分数据操作）,Padel（踏板类），Menulnterface（菜单设置）,PlayGame（游戏界面操作）等类。
经过测试，基本实现设计的开始游戏，排行榜，设置，退出等要求，游戏基本能够正常运行。

关键词

排行榜；模式选择；背景音乐；界面切换；

演示视频

https://b23.tv/UNIC9l

1游戏设计

1．1 开发工具介绍

是英雄就下100层主要在Android Studio上进行开发，维护，在虚拟机上运行。以下为开发过程中的主页面。

Android Studio主页面：

虚拟机上的游戏主页面：

1．2 游戏系统功能介绍

是英雄就下100层游戏的系统功能主要分为四大板块，分别是开始游戏，排行榜，设置和退出。
开始游戏：点击启动图像按钮，自动切换至游戏页面，自动播放音乐，由于在虚拟机上运行，通过鼠标的点击进行左右移动保持游戏的正常运行。当游戏结束的时候，自动跳出得分和用时，并询问重玩或返回主菜单。
排行榜：此游戏为单机，故只有进行了一局以上的游戏，排行榜才会有数据。排行榜根据得分情况依次对所进行的游戏次数进行排列得出排行。
设置：游戏的设置分为两部分，一个是游戏人物的设置，可以选择小红或小蓝两个人物。另一个是游戏难度的设置，分为四个等级，并无太大区别。
退出：点击退出则退出程序至虚拟机主页面。

1．3 游戏流程图

根据游戏功能介绍，游戏流程图也大致分为四个板块。

当游戏在Android studio运行之后，虚拟机自动跳出游戏主界面，背景图片和四个按钮。

当点击开始游戏后，自动切换界面跳转背景和背景音乐（背景音乐在raw文件夹下），游戏正式开始，进行相关操作。当游戏结束后，自动跳出得分。

当点击排行榜按钮后，游戏自动跳出界面显示相关信息包括得分，时间，难度等。

当点击设置按钮，游戏自动跳出设置界面，可进行人物和难度的选择。

当点击退出按钮，则保存相关数据后自动退出。

2 游戏设计

2．1 启动界面设计与实现

此游戏的界面设计主要有五个，分别是activity_game.xml,activity_main.xml,activity_score.xml,activity_setting.xml,my_adapter.xml.

2.1.1 activity_game.xml

其中activity_game.xml主要设计的是在游戏过程中的界面，包括一个ImageButton和一个TextView,主要使用相对布局。如下图所示。

2.1.2 activity_main.xml

其中activity_main.xml主要设计是游戏的主页面，包括四个ImageButton。

主要使用相对布局。如下图所示。

2.1.3 activity_score.xml

其中activity_score.xml主要设计是排行榜的界面，包括一个ListView和两个Button。主要使用两个线性布局。如下图所示。

2.1.4 activity_setting.xml

其中activity_setting.xml主要设计是排行榜的界面，包括两个ImageView,一个RadioGroup,一个TextView，六个Radio Button和两个Button。使用了多个线性布局。如下图所示。

2.1.5 my_adapter.xml

其中my_adapter.xml主要设计是适配器，如下图所示。

2．2 主要类设计与实现

3系统测试

PadelDao类

public class PadelDao  implements  Runnable{
    private static final int PADEL_ADD = 0; //增加踏板命令
    private static final int PADEL_MOVE = 1;    //移动踏板命令
    public  static final int PADEL_SPEED=4; //踏板移动单位数量
    private  int MEN_DEAD = -1;
    private static final int MEN_OUT_DROP_SPEED=PADEL_SPEED*2; //小人掉落的速度单位数量
    public  static int DOWN_TIME=30;  //踏板移动的速度控制
    public  static int ADD_PEDAL_TIME=60; //踏板移动多少次产生新的踏板控制
    private boolean running=true; //控制线程的运转
    private boolean suspen=false; //暂停游戏开关
    private long gameStartTime;  //游戏开始时间记录器
    private long suspenTime=0,continueTime=0;
    private List<Padel> padelsList=new ArrayList<>();
    private Context context;
    private RelativeLayout layout;
    private DisplayMetrics dm;
    private ImageView man;
    private Padel index;
    private int scoreCount=0;
    private TextView textCount;
    private SimpleDateFormat sd;
    private String levelName;   //难度级别名称

    private int imgHeight,imgWidth;
    private Random random;

    public PadelDao(ImageView man, Context context, RelativeLayout layout, DisplayMetrics dm
            ,int downTime,int addPadelTime,String levelName) {
        this.man=man;
        this.context=context;
        this.layout=layout;
        this.dm=dm;
        this.levelName=levelName;
        DOWN_TIME=downTime;
        ADD_PEDAL_TIME=addPadelTime;
        textCount=layout.findViewById(R.id.textCount);
        textCount.setText("第"+scoreCount+"层");

        random=new Random();
        sd=new SimpleDateFormat("mm"+"分"+"ss"+"秒");

        BitmapFactory.Options options = new BitmapFactory.Options();
        BitmapFactory.decodeResource(context.getResources(),R.mipmap.taban,options);
        //获取图片的宽高
        imgHeight = options.outHeight;
        imgWidth = options.outWidth;
    }

    /**
     * 程序运行初始化踏板和小人位置
     */
    public void initPadel(){
        addPadel();

        Padel p=padelsList.get(0);
        index=p;
        int x=p.getX()+(p.getLength()/2);
        int mom=(dm.heightPixels/PadelDao.PADEL_SPEED);
        man.setX(x);             //小人的位置XY坐标初始化
        man.setY(mom*(PadelDao.PADEL_SPEED/2));
        gameStartTime=System.currentTimeMillis();
    }



    /**
     * 随机生产踏板
     */
    public void addPadel(){
        int length=0;
        int x;
        int y=(dm.heightPixels/PADEL_SPEED)*PADEL_SPEED;
        while(true) {
           length = random.nextInt(imgWidth-(imgWidth / 3)) + (imgWidth / 3);
            x= random.nextInt(dm.widthPixels-50)+50;
            if(x+length<dm.widthPixels)
                break;
        }
        ImageView lvPadel=new ImageView(context);
        RelativeLayout.LayoutParams p=new RelativeLayout.LayoutParams(length, 50);
        layout.addView(lvPadel,p);
        lvPadel.setImageResource(R.mipmap.taban);
        lvPadel.setScaleType(ImageView.ScaleType.FIT_XY); //不按比例缩放图片
        lvPadel.setX(x);
        lvPadel.setY(y);
        padelsList.add(new Padel(length,x,y,lvPadel));
    }

    /**
     * 接受子线程发来的消息，并且调用相应的方法执行更新UI操作
     */
    private Handler handler=new Handler(){
        @Override
        public void handleMessage(Message msg) {
            if (msg.what == PADEL_ADD)
                addPadel();
             MovePadal();
        }
    };

    public  void MovePadal(){    //踏板移动方法
        for (int i = 0; i < padelsList.size(); i++) {
            if(padelsList.get(i).getY()==0){
                layout.removeView(padelsList.get(i).getIvPadel());
                padelsList.remove(padelsList.get(i));
                scoreCount++;
                textCount.setText("第"+scoreCount+"层");
            }else
            {
                Padel p=padelsList.get(i);
                ImageView lv =p.getIvPadel();
                p.getIvPadel().setY(p.getY()-PADEL_SPEED);
                p.setY(p.getY()-PADEL_SPEED);
                isAtOutDrop(p.getX(),p.getY(),p.getLength(),p);
            }
        }
        isMenDead();
        moveMen();
    }

    /**
     * 小人的移动方法
     */
    public void moveMen(){
        boolean isDrop;
        int y= (int) man.getY();
        isDrop=isAtOutDrop(index.getX(),index.getY(),index.getLength(),index);
        if(isDrop){
            man.setY(y+MEN_OUT_DROP_SPEED);
        }else
            man.setY(y-PADEL_SPEED);
    }

    /**
     * 判断小人是否掉下
     * @param x 判断条件的X坐标
     * @param y 判断条件的Y坐标
     * @param width 判断条件的踏板长度
     * @return 返回是否掉下 false表明没有掉落，true代表掉下
     */
    public boolean isAtOutDrop(int x,int y,int width,Padel i){
        int manX= (int) man.getX();
        int manY= (int) man.getY();
        int manHeight=manY+man.getHeight();

        if((manX+man.getWidth()-5)>=x && (manX-5)<=(x+width)){    //如果X左边没有掉落的话
            if(y==(manHeight+PADEL_SPEED) || y==manHeight || y==(manHeight+MEN_OUT_DROP_SPEED)
                    || (y+MEN_OUT_DROP_SPEED>=manHeight && (manHeight>=y || manHeight==y-2))){ //如果Y坐标相等的话
                index=i;
                return false;
            }
        }
        return true;
    }

    /**
     * 判断小人是否死亡
     */
    private void isMenDead(){
        int screen=(dm.heightPixels/PADEL_SPEED)*PADEL_SPEED;
        int y= (int) man.getY();
        if(!(y<screen && y>10) && MEN_DEAD==-1){
            MEN_DEAD=1;
            suspen=true;
            long gameEndTime=System.currentTimeMillis();
            long finalGameScore= gameEndTime-gameStartTime-continueTime;
            String date=sd.format(new Date(finalGameScore));

            GameScoreData.scoreData.add(new GameScoreData(scoreCount,date,levelName)); //存储成绩

            PlayGame.mp.pause();

            new AlertDialog.Builder(context).setTitle("Game Over !").setMessage("您在："+date+" 下了："+
            scoreCount+"层\n差点就破纪录啦！").setPositiveButton("返回主菜单",
                    new DialogInterface.OnClickListener() { //返回主菜单的操作
                        @Override
                        public void onClick(DialogInterface dialogInterface, int i) {
                            running=false;
                            if(PlayGame.mp!=null) {//释放掉音乐资源
                                PlayGame.mp.release();
                                PlayGame.mp=null;
                            }
                            try {  //存储信息
                                OutputStream os=context.openFileOutput("Score",Context.MODE_PRIVATE);
                                GameScoreData.Sort(); //先排序
                                GameScoreData.saveScoreData(os);
                            } catch (FileNotFoundException e) {
                                e.printStackTrace();
                            }
                            restore();
                            ((Activity) context).finish();
                        }
                    }).setCancelable(false).setNegativeButton("重新玩", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialogInterface, int i) { //重新初始化游戏的操作
                                restore();
                                suspen=false;
                    PlayGame.mp.start();
                }
            }).show();
        }
    }

   public void restore(){   //还原游戏初始化状态
       for (Padel padel : padelsList) {
           layout.removeView(padel.getIvPadel());
       }
       padelsList.clear();
       scoreCount=0;
       textCount.setText("第"+scoreCount+"层");
       initPadel();
       PlayGame.menX=man.getX();
       MEN_DEAD=-1;
   }

    /**
     * 暂停游戏
     */
    public void suspendGame(){
        suspenTime=System.currentTimeMillis();
        suspen=true;
    }

    /**
     * 继续游戏
     */
    public void continueGame(){
        continueTime=System.currentTimeMillis()-suspenTime;
        suspen=false;
    }


    @Override
    public void run() {
        int count=0;
        while (running){
            while (suspen);  //阻塞线程达到暂停的方法
            try {
                Thread.sleep(DOWN_TIME);
                handler.sendEmptyMessage(PADEL_MOVE);
                if(count==ADD_PEDAL_TIME){
                   handler.sendEmptyMessage(PADEL_ADD);
                    count=0;
                }
                count++;
            } catch (InterruptedException e) {
            }
        }
    }
}

DialogScore类

public class DialogScore extends Dialog {
    private ListView listView;
    private ArrayAdapter adapter;
    private Context context;

    public DialogScore(@NonNull Context context) {
        super(context,R.style.Theme_dialog);
        this.context=context;
        setContentView(R.layout.activity_score);
        listView=findViewById(R.id.list_view);
        adapter=new ArrayAdapter<String>(getContext(),R.layout.my_adapter);
        listView.setAdapter(adapter);

        findViewById(R.id.btn_DialogScore_Back).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                dismiss();
            }
        });

        findViewById(R.id.btn_DialogScore_clear).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
               new AlertDialog.Builder(getContext()).setTitle("提示").setMessage("你确认要删除所有记录吗？")
                       .setPositiveButton("确定", new OnClickListener() {
                           @Override
                           public void onClick(DialogInterface dialogInterface, int i) {
                               adapter.clear();
                               adapter.notifyDataSetChanged();
                               GameScoreData.scoreData.clear();
                               try {  //存储信息
                                   OutputStream os=DialogScore.this.context.openFileOutput("Score",Context.MODE_PRIVATE);
                                   GameScoreData.saveScoreData(os);
                               } catch (FileNotFoundException e) {
                                   e.printStackTrace();
                               }
                           }
                       }).setNegativeButton("放弃", null).show();
            }
        });
    }

    public DialogScore(Context context, int width, int height) {
        this(context);
        Window window = getWindow();
        WindowManager.LayoutParams params = window.getAttributes();

        float density = getDensity(context);
        params.width = (int) (width * density);
        params.height = (int) (height * density);
        params.gravity = Gravity.CENTER;
        window.setAttributes(params);
    }

    private float getDensity(Context context) {
        Resources resources = context.getResources();
        DisplayMetrics dm = resources.getDisplayMetrics();
        return dm.density;
    }

    public void addListData(String data){
        adapter.add(data);
    }
}

DialogSetting 类

public class DialogSetting extends Dialog implements RadioGroup.OnCheckedChangeListener, View.OnClickListener {
    private Button btnSave;
    private Button btnBack;
    private RadioButton men1;
    private RadioButton men2;
    private RadioGroup groupMen;
    private RadioButton level_1;
    private RadioButton level_2;
    private RadioButton level_3;
    private RadioButton level_4;
    private String menName="小红";
    private String levelName="难度";
    public DialogSetting(@NonNull Context context) {
        super(context,R.style.Theme_dialog);
        setContentView(R.layout.activity_setting);

        btnSave=findViewById(R.id.btn_Dialog_Save);
        btnBack=findViewById(R.id.btn_Dialog_Back);
        men1=findViewById(R.id.radioMen1);
        men2=findViewById(R.id.radioMen2);
        groupMen=findViewById(R.id.group_Men);
        level_1=findViewById(R.id.level_1);
        level_2=findViewById(R.id.level_2);
        level_3=findViewById(R.id.level_3);
        level_4=findViewById(R.id.level_4);
        groupMen.setOnCheckedChangeListener(this);
        level_1.setOnClickListener(this);
        level_2.setOnClickListener(this);
        level_3.setOnClickListener(this);
        level_4.setOnClickListener(this);
        btnBack.setOnClickListener(this);
    }

    public DialogSetting(Context context, int width, int height) {
        this(context);
        Window window = getWindow();
        WindowManager.LayoutParams params = window.getAttributes();

        float density = getDensity(context);
        params.width = (int) (width * density);
        params.height = (int) (height * density);
        params.gravity = Gravity.CENTER;
        window.setAttributes(params);
    }

    private float getDensity(Context context) {
        Resources resources = context.getResources();
        DisplayMetrics dm = resources.getDisplayMetrics();
        return dm.density;
    }

    public void setButtobSaveListener(View.OnClickListener listener){
        btnSave.setOnClickListener(listener);
    }

    @Override
    public void onCheckedChanged(RadioGroup radioGroup, @IdRes int i) {

        if(radioGroup.getId() == R.id.group_Men){
            switch (i){
                case R.id.radioMen1:
                    menName=men1.getText().toString();
                    break;
                case R.id.radioMen2:
                    menName=men2.getText().toString();
                    break;
            }
        }
    }


    @Override
    public void onClick(View view) {
        if(view.getId()==R.id.btn_Dialog_Back) {
            menName = null;
            levelName = null;
            dismiss();
        } else {
            switch (view.getId()){
                case R.id.level_1:
                    levelName=level_1.getText().toString();
                    level_2.setChecked(false);
                    level_3.setChecked(false);
                    level_4.setChecked(false);
                    break;
                case R.id.level_2:
                    levelName=level_2.getText().toString();
                    level_1.setChecked(false);
                    level_3.setChecked(false);
                    level_4.setChecked(false);
                    break;
                case R.id.level_3:
                    levelName=level_3.getText().toString();
                    level_2.setChecked(false);
                    level_1.setChecked(false);
                    level_4.setChecked(false);
                    break;
                case R.id.level_4:
                    levelName=level_4.getText().toString();
                    level_2.setChecked(false);
                    level_3.setChecked(false);
                    level_1.setChecked(false);
                    break;
            }
        }
    }

    public String getMenName(){
        return menName;
    }

    public String getLevelName() {
        return levelName;
    }
}

GameScoreData 类

public class GameScoreData implements Serializable {
    public static List<GameScoreData> scoreData=new ArrayList<GameScoreData>();
    private int scoreCount;
    private String scoreDate;
    private String level;

    public GameScoreData(int scoreCount, String scoreDate,String levelName) {
        this.scoreCount = scoreCount;
        this.scoreDate = scoreDate;
        this.level=levelName;
    }

    public static List<GameScoreData> getScoreData() {
        return scoreData;
    }

    public static void setScoreData(List<GameScoreData> scoreData) {
        GameScoreData.scoreData = scoreData;
    }


    public int getScoreCount() {
        return scoreCount;
    }

    public void setScoreCount(int scoreCount) {
        this.scoreCount = scoreCount;
    }

    public String getScoreDate() {
        return scoreDate;
    }

    public void setScoreDate(String scoreDate) {
        this.scoreDate = scoreDate;
    }

    public String getLevel() {
        return level;
    }

    public void setLevel(String level) {
        this.level = level;
    }

    /**
     * 读取数据
     */
    public static void readScoreData(InputStream is){
        try{
            ObjectInputStream ois = new ObjectInputStream(is);
            scoreData= (List<GameScoreData>) ois.readObject();
            ois.close();
        } catch (Exception e) {
        }
    }

    /**
     * 保存数据
     */
    public static void saveScoreData(OutputStream os){
        try {
            ObjectOutputStream ois = new ObjectOutputStream(os);
            ois.writeObject(scoreData);
            ois.flush();
            ois.close();
        }catch (Exception e){
        }
    }

    public static void Sort(){   //排序算法
        int level_1=0;
        int level_2=0;
        int level_3=0;
        int level_4=0;
        for (GameScoreData data : scoreData) {
          switch (data.getLevel()){
              case "难度一":
                 level_1++;
                  break;
              case "难度二":
                  level_2++;
                  break;
              case "难度三":
                  level_3++;
                  break;
              case "难度四":
                  level_4++;
                  break;
          }
        }
        GameScoreData scoreLevel_1[] = new GameScoreData[level_1];
        GameScoreData scoreLevel_2[] = new GameScoreData[level_2];
        GameScoreData scoreLevel_3[] = new GameScoreData[level_3];
        GameScoreData scoreLevel_4[] = new GameScoreData[level_4];

        classify(scoreLevel_1,scoreLevel_2,scoreLevel_3,scoreLevel_4);

        getSortData(scoreLevel_1);
        getSortData(scoreLevel_2);
        getSortData(scoreLevel_3);
        getSortData(scoreLevel_4);

        scoreData.clear();

        newAddArrayData(scoreLevel_1,scoreLevel_2,scoreLevel_3,scoreLevel_4);
    }

    private static void getSortData(GameScoreData[] score){
        if(score.length==0) return;
        for (int i=0;i<score.length;i++){
            for (int j=i+1;j<score.length;j++){
                if(score[i].getScoreCount()<score[j].getScoreCount()){
                    GameScoreData temp=score[i];
                    score[i]=score[j];
                    score[j]=temp;
                }
            }
        }
    }

    private static void classify(GameScoreData[] level_1,GameScoreData[] level_2,GameScoreData[] level_3,
                          GameScoreData[] level_4){
        int level1=0;
        int level2=0;
        int level3=0;
        int level4=0;
        for (GameScoreData data : scoreData) {
            switch (data.getLevel()){
                case "难度一":
                    level_1[level1++]=data;
                    break;
                case "难度二":
                    level_2[level2++]=data;
                    break;
                case "难度三":
                    level_3[level3++]=data;
                    break;
                case "难度四":
                    level_4[level4++]=data;
                    break;
            }
        }
    }

    private static void newAddArrayData(GameScoreData[] level_1,GameScoreData[] level_2,GameScoreData[] level_3,
                                        GameScoreData[] level_4){
        for (GameScoreData g : level_1) {
            scoreData.add(g);
        }

        for (GameScoreData g : level_2) {
            scoreData.add(g);
        }

        for (GameScoreData g : level_3) {
            scoreData.add(g);
        }

        for (GameScoreData g : level_4) {
            scoreData.add(g);
        }

    }
}

Padel 类

public class Padel {
    private int length;
    private int x,y;
    private ImageView ivPadel;

    public Padel(int length, int x, int y, ImageView ivPadel) {
        this.length = length;
        this.x = x;
        this.y = y;
        this.ivPadel = ivPadel;
    }



    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public ImageView getIvPadel() {
        return ivPadel;
    }

    public void setIvPadel(ImageView ivPadel) {
        this.ivPadel = ivPadel;
    }
}

MenuInterface类

public class MenuInterface extends Activity implements View.OnClickListener {

    private SoundPool sp;
    private int songID;
    private DialogSetting dialogSetting;
    private String menName="小红";
    private String level="难度一";
    private int moveTime;   //踏板移动速度
    private int addPadelTime;//生成踏板的时间单位

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        try {
            InputStream is=openFileInput("Score");
            GameScoreData.readScoreData(is);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        setContentView(R.layout.activity_main);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            //透明状态栏
           // getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
            //透明导航栏
            getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
        }

        sp=new SoundPool(0, AudioManager.STREAM_MUSIC,0);
        songID=sp.load(this,R.raw.key_music,1);

        ImageButton btnPlay=findViewById(R.id.btnPlay);
        ImageButton btnSetting=findViewById(R.id.btnSetting);
        ImageButton btnScore=findViewById(R.id.btnScore);
        ImageButton btnExit=findViewById(R.id.btnExit);

        btnPlay.setOnClickListener(this);
        btnSetting.setOnClickListener(this);
        btnScore.setOnClickListener(this);
        btnExit.setOnClickListener(this);

    }

    private void setGameLevelAndMen(){   //难度修改
        switch (level){
            case "难度一":
                moveTime =12;
                addPadelTime =150;
                break;
            case "难度二":
                moveTime =8;
                addPadelTime =180;
                break;
            case "难度三":
                moveTime =5;
                addPadelTime =250;
                break;
            case "难度四":
                moveTime =3;
                addPadelTime =200;
                break;
        }
    }

    @Override
    public void onClick(View view) {
        switch (view.getId()){
            case R.id.btnPlay:
                sp.play(songID,1,1,0,0,1);
                setGameLevelAndMen();
                Bundle data=new Bundle();
                Intent intent=new Intent(this,PlayGame.class);
                data.putInt("Level_MoveTime",moveTime);
                data.putInt("Level_addPadelTime",addPadelTime);
                data.putString("MenName",menName);
                data.putString("Level_Name",level);
                intent.putExtra("data",data);
                startActivity(intent);

                break;
            case R.id.btnSetting:
                sp.play(songID,1,1,0,0,1);
                dialogSetting = new DialogSetting(this,300,500);
                dialogSetting.setCancelable(false);
                dialogSetting.show();
                dialogSetting.setButtobSaveListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View view) {
                        menName=dialogSetting.getMenName();
                        level=dialogSetting.getLevelName();
                        dialogSetting.dismiss();
                    }
                });
                break;
            case R.id.btnScore:
                sp.play(songID,1,1,0,0,1);
                DialogScore dialogScore=new DialogScore(this,300,500);
                for (GameScoreData g : GameScoreData.scoreData) {
                    dialogScore.addListData(String.format("%s%s%s%s%s",g.getLevel()," 成绩：",g.getScoreCount()
                    ,"层 时间：",g.getScoreDate()));
                }
                dialogScore.show();
                break;
            case R.id.btnExit:
                sp.play(songID,1,1,0,0,1);
                finish();
                break;
        }
    }
}

PlayGame 类

public class PlayGame extends Activity implements View.OnClickListener{
    private int x;
    public static float menX;
    private ImageView man;
    private PadelDao padel;
    private RelativeLayout layout;
    private DisplayMetrics dm;
    private ImageButton btnSuspen;
    private SoundPool sp;
    private int songID;
    private int moveTime;
    private int addPadelTime;
    private int menName;
    private String levelName;
    public static MediaPlayer mp;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_game);
        Bundle data=getIntent().getBundleExtra("data");
        moveTime= data.getInt("Level_MoveTime");
        addPadelTime= data.getInt("Level_addPadelTime");
        levelName=data.getString("Level_Name");
        switch (data.getString("MenName")){
            case "小红":
                menName=R.mipmap.men1;
                break;
            case "小蓝":
                menName=R.mipmap.men2;
                break;
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            //透明状态栏
            getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
            //透明导航栏
            //getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
        }

        sp=new SoundPool(0, AudioManager.STREAM_MUSIC,0);
        songID=sp.load(this,R.raw.key_music,1);
        mp=MediaPlayer.create(this,R.raw.b_music);  //初始化音乐资源
        mp.start();
        mp.setLooping(true);

        btnSuspen=findViewById(R.id.btnGameSuspen);
        btnSuspen.setOnClickListener(this);
        layout = findViewById(R.id.lyoutGame);
        dm = getResources().getDisplayMetrics();
        x= dm.widthPixels/2;
        man=new ImageView(this);
        man.setImageResource(menName);
        //man.setScaleType(ImageView.ScaleType.FIT_CENTER);
        man.setLayoutParams(new RelativeLayout.LayoutParams(60, 100));
        man.setScaleType(ImageView.ScaleType.FIT_XY);
        init();
        menX =man.getX();
        layout.addView(man);
    }



    @Override
    public boolean onTouchEvent(MotionEvent event) {
       if(event.getX()>x){  //右边
          if((menX +man.getWidth())<dm.widthPixels)
           man.setTranslationX(menX +=10);
       }
       if(event.getX()<x){  //左边
           if(menX >0)
           man.setTranslationX(menX -=10);
       }
        return true;
    }
    public void init(){
        padel=new PadelDao(man,this, layout,dm,moveTime,addPadelTime,levelName);
        padel.initPadel();
       new Thread(padel).start();
    }



    @Override
    protected void onRestart() {
        mp.start();
        padel.continueGame();
        super.onRestart();
    }

    @Override
    protected void onPause() {
        if(mp!=null) mp.pause();
        super.onPause();
    }

    @Override
    protected void onStop() {
        padel.suspendGame();
        super.onStop();
    }


    @Override
    public void onClick(View view) {  //用户点击了暂停按钮
        sp.play(songID,1,1,0,0,1);
        padel.suspendGame();
        mp.pause();
       new AlertDialog.Builder(this).setTitle("暂停").setMessage("暂停了游戏").setPositiveButton("返回主菜单"
               , new DialogInterface.OnClickListener() {
                   @Override
                   public void onClick(DialogInterface dialogInterface, int i) {
                        mp.release();
                        mp=null;
                        finish();
                   }
               }).setNegativeButton("继续游戏", new DialogInterface.OnClickListener() {
           @Override
           public void onClick(DialogInterface dialogInterface, int i) {
               padel.continueGame();
               mp.start();
           }
       }).setCancelable(false).show();
    }

    @Override
    public void onBackPressed() {   //用户按下返回键的监听事件
        padel.suspendGame();
        mp.pause();
        new AlertDialog.Builder(this).setTitle("暂停").setMessage("暂停了游戏").setPositiveButton("返回主菜单"
                , new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        mp.release();
                        mp=null;
                        finish();
                    }
                }).setNegativeButton("继续游戏", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialogInterface, int i) {
                padel.continueGame();
                mp.start();
            }
        }).setCancelable(false).show();

    }
}

经过测试，是英雄就下100层游戏运行正常，达到设计目标。