Android实现连连看游戏

package packageName;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.LinearLayout;

import MaView;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ViewGroup.LayoutParams params = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
        final MaView mainView = new MaView(this);
        addContentView(mainView, params);
        // 添加三个按钮执行相应的方法
        Button btn = new Button(this);
        btn.setText("新游戏");
        btn.setTextSize(20);
        btn.setX(40);
        btn.setY(40);
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mainView.newGame();
            }
        });
        addContentView(btn, params);

        Button tipBtn = new Button(this);
        tipBtn.setText("提示");
        tipBtn.setTextSize(20);
        tipBtn.setX(380);
        tipBtn.setY(40);
        tipBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mainView.getTip();
            }
        });
        addContentView(tipBtn, params);

        Button resetBtn = new Button(this);
        resetBtn.setText("重置");
        resetBtn.setTextSize(20);
        resetBtn.setX(720);
        resetBtn.setY(40);
        resetBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mainView.reset();
            }
        });
        addContentView(resetBtn, params);
    }
}

package packageName;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Picture;
import android.graphics.Rect;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.PictureDrawable;
import android.os.Build;
import android.support.annotation.RequiresApi;
import android.transition.Explode;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.widget.Toast;

import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;

public class MaView extends View {
    // 连连看规则: 在一个方形有若干个格子，当选择其中的两个格子时，存在以下几种连线关系时就会被消灭
    // 连线只有水平和垂直方向
    // 1, 其水平或垂直方向相同，并且两个格子之间无其它非空格子的直线关系
    // 2, 有一个折点的 一折点关系
    // 3, 有两个折点的 二折点关系

    // 左边距
    public static final int MARGINLEFT = 40;
    // 上边距
    public static final int MARGINTOP = 400;
    // 格子的行列数
    public static final int ROW = 10;
    // 格子的宽高
    public static final int W = 100;
    // 图片的宽高
    public static final int IMGW = 90;
    // 格子为空
    public static final int NULL = -1;
    // 连接状态为 直线
    public static final int STRAIGHT = 1;
    // 连接状态为 一折点
    public static final int ONELINK = 2;
    // 连接状态为 二折点
    public static final int TWOLINK = 3;
    // 格子的种类数
    public static final int L = 25;
    // 存放格子信息的地图
    private int[] map = new int[ROW * ROW];
    // 存放格子的图片
    private Bitmap[] imgs = new Bitmap[L];
    // 判断触屏事件是否为点击
    private boolean isMove;
    // 是否为第一次选择格子
    private boolean isFirstSelect;
    // 是否可以画连接线和格子的选中边框
    private boolean canDrawLine, canDrawRect;
    // 是否有提示，没有的话要重置当前格子位置
    private boolean canTip;
    // 是否可以选择格子
    private boolean canPlay;
    // 是否已经点击了提示
    private boolean firstTip;
    // 存储第一次和第二次选中方块的位置
    private int x1 = NULL, y1 = NULL, x2 = NULL, y2 = NULL;
    // 第一个折点和第二个折点的位置
    private int px1, py1, px2, py2;
    // 连接线的类别
    private int linkState;
    // 计数器，用于解决异步问题
    private int count = 0;

    public MaView(Context context) {
        super(context);
        // 初始化图片
        initImg();
        // 初始化游戏
        newGame();
        // 设置触屏事件
        setOnTouchListener(new OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                // 当前状态不可以点击，如画连接线时会有 0.5 秒的等待时间
                if (!canPlay) {
                    return false;
                }
                switch (event.getAction()) {
                    case MotionEvent.ACTION_DOWN:
                        isMove = false;
                        break;
                    case MotionEvent.ACTION_MOVE:
                        isMove = true;
                    case MotionEvent.ACTION_UP:
                        // 若为移动事件则不执行
                        if (!isMove) {
                            // 获取当前点击的位置在网格中的位置
                            int x = (int) event.getX() - MARGINLEFT;
                            int y = (int) event.getY() - MARGINTOP;
                            // 是否超出边界
                            if (x < 0 || x > W * ROW || y < 0 || y > W * ROW) {
                                return false;
                            }
                            // 转化为格子的坐标
                            // x 为列， y 为行
                            x = x / W % ROW;
                            y = y / W;
                            // 是否为第一次选择
                            if (isFirstSelect) {
                                // 点击的位置是否为空格子
                                if (map[y * ROW   x] == NULL) {
                                    return false;
                                }
                                // 存储第一个格子的位置
                                x1 = x;
                                y1 = y;
                                // 可以画边框
                                canDrawRect = true;
                                isFirstSelect = false;
                                // View 自带的方法，会异步执行 onDraw() 方法，起到更新视图的作用
                                invalidate();
                            } else {
                                if (map[y * ROW   x] == NULL) {
                                    return false;
                                }
                                // 点击的格子是是同一个则重置选择
                                if (x1 == x && y1 == y) {
                                    noDraw();
                                    // 更新视图
                                    invalidate();
                                    return false;
                                }
                                // 存储第二个格子的位置
                                x2 = x;
                                y2 = y;
                                // 判断两个格子是否相同
                                if (map[y1 * ROW   x1] == map[y2 * ROW   x2]) {
                                    // 是否可以连接
                                    if (isCanLink(x1, y1, x2, y2)) {
                                        canDrawLine = true;
                                        // 更新视图
                                        invalidate();
                                        // 计数器，防止视图效果不同步
                                        count  ;
                                        waitLose();
                                    } else {
                                        noDraw();
                                        invalidate();
                                    }
                                } else {
                                    noDraw();
                                    invalidate();
                                }
                            }
                        }
                }
                return true;
            }
        });
    }
    
    // 判断是否赢了
    private boolean isWin() {
        for (int i = 0; i < ROW * ROW; i  ) {
            if (map[i] != NULL) {
                return false;
            }
        }
        return true;
    }
    
    // 判断是否可以将消除的格子
    private void waitLose() {
        if (count == 2) {
            map[y2 * ROW   x2] = NULL;
            map[y1 * ROW   x1] = NULL;
            count = 0;
        }
    }

    // 开始新游戏
    public void newGame() {
        randomMap();
        noDraw();
        firstTip = true;
        canPlay = true;
        invalidate();
    }

    private boolean isCanLink(int x1, int y1, int x2, int y2) {
        // 要经过直线连接，一折点连接，二折点连接三个判断

        // 垂直直线连接, 其列坐标相同
        if (x1 == x2 && isVLink(x1, y1, y2)) {
            linkState = STRAIGHT;
            return true;
        }
        // 水平直线连接，其行坐标相同
        if (y1 == y2 && isHLink(y1, x1, x2)) {
            linkState = STRAIGHT;
            return true;
        }
        // 判断一个折点的连接
        if (isOneLink(x1, y1, x2, y2)) {
            linkState = ONELINK;
            return true;
        }
        // 判断两个折点的连接
        if (isTwoLink(x1, y1, x2, y2)) {
            linkState = TWOLINK;
            return true;
        }
        return false;
    }
    // 垂直直线判断

    private boolean isVLink(int x1, int y1, int y2) {
        // 保证 y1 永远不大于 y2
        if (y1 > y2) {
            int t = y1;
            y1 = y2;
            y2 = t;
        }
        // 遍历 x, y1 到 y2 的格子
        for (int i = y1   1; i < y2; i  ) {
            // 有一个不为空则不能连接
            if (map[i * ROW   x1] != NULL) {
                return false;
            }
        }
        return true;
    }

    // 水平直线判断
    private boolean isHLink(int y1, int x1, int x2) {
        // 保证 x1 永远不大于 x2
        if (x1 > x2) {
            int t = x1;
            x1 = x2;
            x2 = t;
        }
        // 遍历 x1 到 x2, y 的格子
        for (int i = x1   1; i < x2; i  ) {
            // 有一个不为空则不能连接
            if (map[y1 * ROW   i] != NULL) {
                return false;
            }
        }
        return true;
    }

    // 两个折点判断
    private boolean isTwoLink(int x1, int y1, int x2, int y2) {
        // 保证第一个坐标在左边，便于遍历
        if (x1 > x2) {
            int t = x1;
            x1 = x2;
            x2 = t;
            t = y1;
            y1 = y2;
            y2 = t;
        }
        // 有四个方向判断
        // top
        // 先将第一个折点上移，然后将第一个折点与第二个坐标用 矩形连接法 进行判断
        for (int i = y1 - 1; i >= -1; i--) {
            // 若到达了边界，则判断第二个坐标在这个方向是否也能到达边界，若能则可以连接
            if (i == -1) {
                // 第二个坐标是否能到达上边界
                if (isCanTop(x2, y2)) {
                    // 存储第一个和第二个折点
                    px1 = x2;
                    py1 = i;
                    px2 = x1;
                    py2 = i;
                    return true;
                }
                break;
            }
            if (map[x1   i * ROW] != NULL) {
                break;
            }
            if (isOneLink(x1, i, x2, y2)) {
                // 存储第二个折点，第一个折点在 一折点连接 中存了
                px2 = x1;
                py2 = i;
                return true;
            }
        }
        // down
        for (int i = y1   1; i <= ROW; i  ) {
            if (i == ROW) {
                if (isCanDown(x2, y2)) {
                    px1 = x2;
                    py1 = i;
                    px2 = x1;
                    py2 = i;
                    return true;
                }
                break;
            }
            if (map[x1   i * ROW] != NULL) {
                break;
            }
            if (isOneLink(x1, i, x2, y2)) {
                px2 = x1;
                py2 = i;
                return true;
            }
        }
        // left
        for (int i = x1 - 1; i >= -1; i--) {
            if (i == -1) {
                if (isCanLeft(x2, y2)) {
                    px2 = i;
                    py2 = y1;
                    px1 = i;
                    py1 = y2;
                    return true;
                }
                break;
            }
            if (map[i   y1 * ROW] != NULL) {
                break;
            }
            if (isOneLink(i, y1, x2, y2)) {
                px2 = i;
                py2 = y1;
                return true;
            }
        }
        // right
        for (int i = x1   1; i <= ROW; i  ) {
            if (i == ROW) {
                if (isCanRight(x2, y2)) {
                    px2 = i;
                    py2 = y1;
                    px1 = i;
                    py1 = y2;
                    return true;
                }
                break;
            }
            if (map[i   y1 * ROW] != NULL) {
                break;
            }
            if (isOneLink(i, y1, x2, y2)) {
                px2 = i;
                py2 = y1;
                return true;
            }
        }
        return false;
    }
    
    private boolean isCanTop(int x2, int y2) {
        // 遍历坐标与上边界之间的格子，若又不为空的则不能
        for (int i = y2 - 1; i >= -1; i--) {
            if (i == -1) {
                break;
            }
            if (map[i * ROW   x2] != NULL) {
                return false;
            }
        }
        return true;
    }

    private boolean isCanLeft(int x2, int y2) {
        for (int i = x2 - 1; i >= -1; i--) {
            if (i == -1) {
                break;
            }
            if (map[y2 * ROW   i] != NULL) {
                return false;
            }
        }
        return true;
    }

    private boolean isCanRight(int x2, int y2) {
        for (int i = x2   1; i <= ROW; i  ) {
            if (i == ROW) {
                break;
            }
            if (map[y2 * ROW   i] != NULL) {
                return false;
            }
        }
        return true;
    }

    private boolean isCanDown(int x2, int y2) {
        for (int i = y2   1; i <= ROW; i  ) {
            if (i == ROW) {
                break;
            }
            if (map[i * ROW   x2] != NULL) {
                return false;
            }
        }
        return true;
    }

    // 一个折点判断
    private boolean isOneLink(int x1, int y1, int x2, int y2) {
        // 保证第一个坐标在左边，便于遍历
        if (x1 > x2) {
            int t = x1;
            x1 = x2;
            x2 = t;
            t = y1;
            y1 = y2;
            y2 = t;
        }
        // 一个折点的用 矩形判断法， 两个坐标在对角处，折点在另外的对角处
        // 先判断这个折点是否为空，不为空就不能连接
        // 为空就将两个坐标点与这个折点用直线连接判断，若可以，则可以连接
        if (map[y1 * ROW   x2] == NULL) {
            if (isHLink(y1, x1, x2) && isVLink(x2, y1, y2)) {
                // 存储第一个折点的位置，便于画线
                px1 = x2;
                py1 = y1;
                return true;
            }
        }
        // 另外一个折点
        if (map[x1   y2 * ROW] == NULL) {
            // 注意 x, y 的变换位置
            if (isHLink(y2, x1, x2) && isVLink(x1, y1, y2)) {
                // 存储第一个折点的位置，便于画线
                px1 = x1;
                py1 = y2;
                return true;
            }
        }
        return false;
    }

    private void initImg() {
        int id;
        for (int i = 0; i < imgs.length; i  ) {
            id = getResources().getIdentifier("a"   (i   1), "drawable", getContext().getPackageName());
            // 显示图片原尺寸
//            BitmapFactory.Options options = new BitmapFactory.Options();
//            options.inScaled = false;
            imgs[i] = BitmapFactory.decodeResource(getResources(), id);

            int w = imgs[i].getWidth();
            int h = imgs[i].getHeight();
            Matrix matrix = new Matrix();
            matrix.postScale(IMGW * 1.0f / w, IMGW * 1.0f / h);

            imgs[i] = Bitmap.createBitmap(imgs[i], 0, 0, w, h, matrix, true);
        }
    }

    private Bitmap getMyImg(Bitmap rootImg, int goalW, int goalH) {
        int rootW = rootImg.getWidth();
        int rootH = rootImg.getHeight();
        // graphics 包下的
        Matrix matrix = new Matrix();
        matrix.postScale(goalW * 1.0f / rootW, goalH * 1.0f / rootH);
        return Bitmap.createBitmap(rootImg, 0, 0, rootW, rootH, matrix, true);
    }

    private void randomMap() {
        // 初始化地图并将位置打乱
        int c = 0;
        // 每种格子有四个
        for (int i = 0; i < L; i  ) {
            for (int j = 0; j < 4; j  ) {
                map[c] = i;
                c  ;
            }

        }
        // 循环 500 次打乱位置
        int a, b, t;
        Random random = new Random();
        for (int i = 0; i < 500; i  ) {
            a = random.nextInt(ROW * ROW);
            b = random.nextInt(ROW * ROW);
            if (map[a] == NULL || map[b] == NULL) {
                continue;
            }
            t = map[a];
            map[a] = map[b];
            map[b] = t;
        }
    }

//    private void showMap() {
//        String s = "";
//        int c = 0;
//        for (int i = 0; i < ROW; i  ) {
//            for (int j = 0; j < ROW; j  ) {
//                s  = map[c]   " ";
//                c  ;
//            }
//            s = "";
//        }
//    }

    @Override
    protected void onDraw(Canvas canvas) {
        int x, y;
        int c = 0;
        // 画格子
        for (int i = 0; i < ROW; i  ) {
            for (int j = 0; j < ROW; j  ) {
                x = MARGINLEFT   j * W;
                y = MARGINTOP   i * W;
                if (map[c] != NULL) {
                    canvas.drawBitmap(imgs[map[c]], x, y, new Paint());
                }
                c  ;
            }
        }
        // 画提示的格子边框
        if (canTip) {
            // 设置线条的样式
            Paint paint = new Paint();
            paint.setStrokeWidth(8);
            paint.setColor(Color.parseColor("#08ffc8"));
            paint.setStyle(Paint.Style.STROKE);
            x = x1 * W   MARGINLEFT;
            y = y1 * W   MARGINTOP;
            canvas.drawRect(x, y, x   W - 3, y   W - 3, paint);
            x = x2 * W   MARGINLEFT;
            y = y2 * W   MARGINTOP;
            canvas.drawRect(x, y, x   W - 3, y   W - 3, paint);
            canTip = false;
            noDraw();
        }
        // 画已选格子的边框
        if (canDrawRect) {
            Paint paint = new Paint();
            paint.setStrokeWidth(8);
            paint.setColor(Color.RED);
            paint.setStyle(Paint.Style.STROKE);
            // 第一个格子
            if (x1 != NULL) {
                x = x1 * W   MARGINLEFT;
                y = y1 * W   MARGINTOP;
                canvas.drawRect(x, y, x   W - 3, y   W - 3, paint);
                firstTip = true;
            }
            // 第二个格子
            if (x2 != NULL) {
                x = x2 * W   MARGINLEFT;
                y = y2 * W   MARGINTOP;
                canvas.drawRect(x, y, x   W - 3, y   W - 3, paint);
                count  ;
                waitLose();
            }
        }
        // 画连接线
        if (canDrawLine) {
            Paint paint = new Paint();
            paint.setStrokeWidth(8);
            paint.setColor(Color.RED);
            paint.setStyle(Paint.Style.FILL);

            int sx1, sy1, sx2, sy2, zx1, zy1, zx2, zy2;
            // 第一个坐标
            sx1 = x1 * W   W   MARGINLEFT - W / 2;
            sy1 = y1 * W   W   MARGINTOP - W / 2;
            // 第二个坐标
            sx2 = x2 * W   W   MARGINLEFT - W / 2;
            sy2 = y2 * W   W   MARGINTOP - W / 2;
            switch (linkState) {
                case STRAIGHT:
                    // 画直线
                    canvas.drawLine(sx1, sy1, sx2, sy2, paint);
                    break;
                case ONELINK:
                    // 画一折点线
                    zx1 = px1 * W   MARGINLEFT   W / 2;
                    zy1 = py1 * W   MARGINTOP   W / 2;
                    canvas.drawLine(sx1, sy1, zx1, zy1, paint);
                    canvas.drawLine(zx1, zy1, sx2, sy2, paint);
                    break;
                case TWOLINK:
                    // 画二折点线
                    // 第二个折点
                    zx1 = px1 * W   MARGINLEFT   W / 2;
                    zy1 = py1 * W   MARGINTOP   W / 2;
                    // 第一个折点
                    zx2 = px2 * W   MARGINLEFT   W / 2;
                    zy2 = py2 * W   MARGINTOP   W / 2;
                    // 到边界了改变一下线条的位置
                    if (px1 == -1) {
                        zx1  = 30;
                        zx2  = 30;
                    } else if (px1 == ROW) {
                        zx1 -= 30;
                        zx2 -= 30;
                    }
                    // 有左右两种情况，上下两种情况，但第一个折点一定与第一个坐标的 x 或 y 相同
                    if (px1 == x1 || py1 == y1) {
                        int t = zx1;
                        zx1 = zx2;
                        zx2 = t;
                        t = zy1;
                        zy1 = zy2;
                        zy2 = t;
                    }
                    canvas.drawLine(sx1, sy1, zx2, zy2, paint);
                    canvas.drawLine(zx2, zy2, zx1, zy1, paint);
                    canvas.drawLine(zx1, zy1, sx2, sy2, paint);
            }
            noDraw();
            // 画线过程不能点击
            canPlay = false;
            // 开一个线程做连接效果
            new Timer().schedule(new TimerTask() {
                @Override
                public void run() {
                    // 这个方法用于转到主线程中执行，更新视图操作必须放到主线程中执行 其 invalidate() 跟新了视图
                    post(new Runnable() {
                        @Override
                        public void run() {
                            invalidate();
                            // 判断是否赢了没
                            if (isWin()) {
                                Toast.makeText(getContext(), "You Win! Please New Game", Toast.LENGTH_SHORT).show();
                            }
                            // 可以点击了
                            canPlay = true;
                        }
                    });
                }
            }, 500);
        }
    }

    // 重置当前图片的位置
    public void reset() {
        if (!canPlay) {
            return;
        }
        int a, b, t;
        Random random = new Random();
        for (int i = 0; i < 500; i  ) {
            a = random.nextInt(ROW * ROW);
            b = random.nextInt(ROW * ROW);
            if (map[a] == NULL || map[b] == NULL) {
                continue;
            }
            t = map[a];
            map[a] = map[b];
            map[b] = t;
        }
        invalidate();
    }

    // 获取提示
    public void getTip() {
        if (!canPlay) {
            return;
        }
        // 不能连续点击
        if (!firstTip) {
            Toast.makeText(getContext(), "Alright Tip!", Toast.LENGTH_SHORT).show();
            return;
        }
        firstTip = false;
        int count = 0;
        int x1, y1, x2, y2;
        Tag:
        for (int i = 0; i < ROW * ROW; i  ) {
            if (map[i] == NULL) {
                continue;
            }
            for (int j = i   1; j < ROW * ROW; j  ) {
                if (map[j] == NULL) {
                    continue;
                }
                if (map[i] == map[j]) {
                    x1 = i % ROW;
                    y1 = i / ROW;
                    x2 = j % ROW;
                    y2 = j / ROW;
                    if (isCanLink(x1, y1, x2, y2)) {
                        count  ;
                        this.x1 = x1;
                        this.y1 = y1;
                        this.x2 = x2;
                        this.y2 = y2;
                        break Tag;
                    }
                }
            }
        }
        // 不为空则有可连接的格子
        if (count != 0) {
            canTip = true;
            invalidate();
        } else {
            Toast.makeText(getContext(), "No One! Please Click New Game", Toast.LENGTH_SHORT).show();
        }
    }

    // 重置选择格子
    private void noDraw() {
        canDrawRect = false;
        canDrawLine = false;
        isFirstSelect = true;
        x1 = NULL;
        x2 = NULL;
        y1 = NULL;
        y2 = NULL;
    }
}