Android Studio实现连连看小游戏，比比看谁过关最快~_android studio小游戏

一、项目概述

这是一款基于Android studio开发的连连看小游戏。主要实现的功能有：

• 难度设置
• 打乱重排
• 排行榜
• 计时器
• 背景音乐
• 消除音效

二、主要技术

主要应用的技术如下：

本项目几乎涵盖了Android入门级的所有知识点，适合新手练手实践。

三、开发环境

四、详细设计

1、数据库

创建了一张users表来存储排行榜的数据，建表语句如下：

db.execSQL("create table users (id integer primary key,name varchar(50),time varchar(50),date varchar(50))");
1

与以往的数据库帮助类不同，这次并没有提前创建好数据库和表，而是在类中调用构造函数进行创建，创建之后会自动执行建表语句。因为要加上表头，所以我们在建表之后率先插入一条数据作为表头。

myDBHelper = new DataBaseHelper(this,"ranking",null,1);
db = myDBHelper.getWritableDatabase();
Cursor cursor = db.query("users", null, null, null, null, null, "time");
mData = new LinkedList<>();
mData.add(new Ranking("名次","昵称","用时(s)","上榜时间"));
1
2
3
4
5

游戏所有的配置采用键值对形式存储——“背景音乐”：“开”。所以使用SharedPreferences，通过读取key的value判断是否关闭音乐/音效。

sp = this.getSharedPreferences("config",MODE_PRIVATE);
if(sp.getBoolean("music",true)) {
    mp.start();
}
if(!sp.getBoolean("sound",true)) {
    sound = false;
}
1
2
3
4
5
6
7

2、排行榜

首先肯定创建排行榜的实体类，其实就是数据表的结构。类的属性、构造函数、get和set方法。

public class Ranking {
    private String id;
    private String name;
    private String time;
    private String date;

    public Ranking(String id, String name, String time, String date) {
        this.id = id;
        this.name = name;
        this.time = time;
        this.date = date;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getTime() {
        return time;
    }

    public void setTime(String time) {
        this.time = time;
    }

    public String getDate() {
        return date;
    }

    public void setDate(String date) {
        this.date = date;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

因为要在列表中显示排行榜，所以需要自定义适配器。然后获取数据源，创建适配器，加载适配器即可。这部分内容属于老生常谈了，就当复习一下。

/* 排行榜列表的适配器 */
public class RankingAdapter extends BaseAdapter {
    private LinkedList<Ranking> mData;
    private Context mContext;

    public RankingAdapter(LinkedList<Ranking> mData, Context mContext) {
        this.mData = mData;
        this.mContext = mContext;
    }

    @Override
    public int getCount() {
        return mData.size();
    }

    @Override
    public Object getItem(int position) {
        return null;
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        convertView = LayoutInflater.from(mContext).inflate(R.layout.ranking_item,null);
        TextView uid = convertView.findViewById(R.id.uid);
        TextView uname = convertView.findViewById(R.id.uname);
        TextView utime = convertView.findViewById(R.id.utime);
        TextView udate = convertView.findViewById(R.id.udate);
        uid.setText(mData.get(position).getId());
        uname.setText(mData.get(position).getName());
        utime.setText(mData.get(position).getTime());
        udate.setText(mData.get(position).getDate());
        return convertView;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

3、游戏实现

因为连连看游戏是消除一个个小方块，所以最基本的游戏单元就是方块类。每个方块有哪些属性呢？首先方块上面有图片，有自己在屏幕上的左上角坐标（x，y），以及在二维数组中的一维和二维索引值。有哪些方法呢？首先必须能够判断两个Piece上的图片是否相同，不然无法进入消除判断，然后获取方块中心点坐标，用于画图。

/* 方块对象 */
public class Piece {
    /**
     * 保存方块对象的所对应的图片
     */
    private PieceImage pieceImage;
    /**
     * 该方块的左上角的x坐标
     */
    private int beginX;
    /**
     * 该方块的左上角的y座标
     */
    private int beginY;
    /**
     * 该对象在Piece[][]数组中第一维的索引值
     */
    private int indexX;
    /**
     * 该对象在Piece[][]数组中第二维的索引值
     */
    private int indexY;

    /**
     * 设置该Piece对象在数组中的索引值
     *
     * @param indexX
     *            该方块的左上角的x坐标
     * @param indexY
     *            该方块的左上角的y座标
     */
    public Piece(int indexX, int indexY) {
        this.indexX = indexX;
        this.indexY = indexY;
    }

    /**
     * 获取该Piece的中心位置
     *
     * @return 中心点的坐标对象Point
     */
    public Point getCenter() {
        return new Point(getBeginX() + GameConf.PIECE_WIDTH / 2, getBeginY() + GameConf.PIECE_HEIGHT / 2);
    }

    /**
     * 判断两个Piece上的图片是否相同
     *
     * @param otherPieceImage
     *            另外的一个Piece对象
     * @return 是否相同
     */
    public boolean isSameImage(Piece otherPieceImage) {
        if (pieceImage == null) {
            if (otherPieceImage.pieceImage != null)
                return false;
        }
        // 当两个Piece封装图片资源ID相同时，即可认为这两个Piece上的图片相同。
        return pieceImage.getImageId() == otherPieceImage.pieceImage
                .getImageId();
    }

    /**
     * @return 该方块的左上角的X坐标
     */
    public int getBeginX() {
        return beginX;
    }

    /**
     * 设置该方块的左上角的X坐标
     *
     * @param beginX
     */
    public void setBeginX(int beginX) {
        this.beginX = beginX;
    }

    /**
     * @return 该方块的左上角的Y座标
     */
    public int getBeginY() {
        return beginY;
    }

    /**
     * 设置该方块的左上角的Y坐标
     *
     * @param beginY
     */
    public void setBeginY(int beginY) {
        this.beginY = beginY;
    }

    /**
     * @return 该对象在Piece[][]数组中第一维的索引值
     */
    public int getIndexX() {
        return indexX;
    }

    /**
     * 设置该对象在Piece[][]数组中第一维的索引值
     *
     * @param indexX
     */
    public void setIndexX(int indexX) {
        this.indexX = indexX;
    }

    /**
     * @return 该对象在Piece[][]数组中第二维的索引值
     */
    public int getIndexY() {
        return indexY;
    }

    /**
     * 设置该对象在Piece[][]数组中第二维的索引值
     *
     * @param indexY
     */
    public void setIndexY(int indexY) {
        this.indexY = indexY;
    }

    /**
     * @return 保存方块对象的所对应的图片
     */
    public PieceImage getPieceImage() {
        return pieceImage;
    }

    /**
     * 设置保存方块对象的所对应的图片
     *
     * @param pieceImage
     */
    public void setPieceImage(PieceImage pieceImage) {
        this.pieceImage = pieceImage;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

方块图片很简洁，两个属性分别是image位图和image的id。

 /**
  * 图片
  */
 private Bitmap image;
 /**
  * 图片资源ID
  */
 private int imageId;
1
2
3
4
5
6
7
8

做完这些后，我们就可以将方块放入到我们的屏幕中了，这时候定义个平板类，每次打乱方块。

protected List<Piece> createPieces(GameConf config, Piece[][] pieces) {
    List<Piece> notNullPieces = new ArrayList<Piece>();
    for (int i = 0; i < pieces.length; i++) {
        for (int j = 0; j < pieces[i].length; j++) {
            Piece piece = new Piece(i, j);
            notNullPieces.add(piece);
        }
    }
    return notNullPieces;
}
1
2
3
4
5
6
7
8
9
10

我们创建了一个类用来保存连接点，方法直接调用。

private List<Point> points = new ArrayList<Point>();
1

获取到所有连接点后，开始在画布上画线，这样就有了动画效果。

private void drawLine(LinkInfo linkInfo, Canvas canvas) {
      // 获取LinkInfo中封装的所有连接点
      List<Point> points = linkInfo.getLinkPoints();
      // 依次遍历linkInfo中的每个连接点
      for (int i = 0; i < points.size() - 1; i++) {
          // 获取当前连接点与下一个连接点
          Point currentPoint = points.get(i);
          Point nextPoint = points.get(i + 1);
          // 绘制连线
          canvas.drawLine(currentPoint.x, currentPoint.y, nextPoint.x,
                  nextPoint.y, this.paint);
      }
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14

最后在主碎片上面设置游戏中的逻辑，篇幅比较长，代码也比较简单，大家可以直接阅读源码学习。

// 初始化游戏失败的对话框
lostDialog = createDialog("GAME OVER", "游戏失败！请重新开始", R.drawable.lost)
       .setPositiveButton("确定", new DialogInterface.OnClickListener() {
           public void onClick(DialogInterface dialog, int which) {
               startGame(0);
           }
       });
// 初始化游戏胜利的对话框
successDialog = createDialog("Success", "你真厉害！请输入你的大名！",
       R.drawable.success).setView(et).setPositiveButton("确定",
       new DialogInterface.OnClickListener() {
           public void onClick(DialogInterface dialog, int which) {
               String input = et.getText().toString();
               myDBHelper = new DataBaseHelper(getContext(),"ranking",null,1);
               db = myDBHelper.getWritableDatabase();
               Time t=new Time();
               t.setToNow();
               int year = t.year;
               int month = t.month+1;
               int day = t.monthDay;
               String date = year+"/"+month+"/"+day;
               ContentValues cv = new ContentValues();
               cv.put("name",input);
               cv.put("time",String.valueOf(gameTime));
               cv.put("date",date);
               db.insert("users",null,cv);
               Intent intent = new Intent();
               intent.setAction("top.ysccx.broadcast");
               intent.putExtra("name",input);
               intent.putExtra("time",String.valueOf(gameTime));
               getActivity().sendBroadcast(intent);
               startActivity(new Intent(getActivity(),RankingActivity.class));
           }
       });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

五、运行演示

1、Build项目，运行到模拟器中，可以看到默认碎片显示游戏界面，底部导航栏和顶部菜单栏。

2、我们点击右上角的下拉菜单，有难度、排行榜、打乱重排、重新开始和退出五个选项。

3、在难度菜单项中还有子菜单，从简单和地狱的难度，满足你的一切渴望。

4、我们先选择简单难度，然后点击Play，游戏开始，方块随机排列在屏幕上，底部是计时。

5、然后进行消除，消除时候有背景音乐和音效，消除会有动画。

6、消除成功后弹出对话框，输入昵称用来排行。

7、输入昵称可以自动跳转到排行榜，也可以点击菜单栏查看排行榜。

8、如果消除时候遇到死局，可以在菜单栏选择【打乱重排】，然后就会随机打乱剩余的方块。

9、玩的不满意了就重新开始，也都没有问题的。

10、我们点击导航栏的说明，可以看到游戏说明，原来是周杰伦制作的游戏啊（因为我非常喜欢周杰伦）。

11、在设置导航栏中可以选择打开音乐或者音效。

六、源码获取

关注公众号《萌新加油站》，后台回复：连连看

点此直接下载源码：声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/798322