位置：首页-资讯-移动开发

Android实现九格智能拼图算法

2024-04-02 19:55

短信预约 -IT技能 免费直播动态提醒

最近想业余做一款android游戏，发现我国一款古老好玩的智力游戏-九格智能拼图挺好玩的，相信大多80后小时玩过，因此有了开发的想法。

一、九格智能拼图

游戏规则：将一副图片分割为9个子图片，其中一个为空白图片，随机打乱。通过两两图片的交换，合并为一张图片，最后游戏完成。

二、开发步骤

1、将一个图片分割为9个子图片，放入ArrayList中。

利用Bitmap.createBitmap()进行图片切割，根据参数坐标的不同，可以切图一张图片的任意部分。

2、采用自定义view，随机打乱的画出9个子图片

选生成0-9的随机排列。然后根据排列值画出对应的图片

3、在自定义view中响应点击图片是否可以移动。

遍历左右方块数字，如果为0,则可以移动。同时交换相连数字和数组中的位置。

4、判断游戏完成的结束算法。

依次遍历各个方块，如何数字呈依次递增排列，则游戏结束

代码：

package org.diudiululu.magicSquare;
 
import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.Point;
import android.os.Bundle;
import android.util.Log;
 

public class MagicSquareActivity extends Activity {
    private static final String TAG = "MagicSquare";
    public static final int SQUARE_WIDTH = 3;
 
    private int square[] = new int[SQUARE_WIDTH * SQUARE_WIDTH];
 
    private int steps = 0;
 
    private MagicSquareView magicSquareView;
 
    public int getTitleNumber(int x, int y) {
        return square[y * SQUARE_WIDTH + x];
    }
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(this.TAG, "OnCreate");
 
        initGame();
 
        magicSquareView = new MagicSquareView(this);
 
        this.setContentView(magicSquareView);
        magicSquareView.requestFocus();
    }
 
    private void initGame() {
        generateMagicSquare();
        steps = 0;
    }
 
    private void generateMagicSquare() {
        java.util.ArrayList<Integer> numArray = new java.util.ArrayList<Integer>();
 
        for (int i = 0; i < square.length; i++) {
            numArray.add(new Integer(i));
        }
 
        int i = 0;
        while (numArray.size() > 0) {
            int index = (int) (Math.random() * numArray.size());
            Integer integer = numArray.get(index);
            square[i] = integer.intValue();
            i++;
            numArray.remove(index);
        }
    }
 
    public boolean moveable(int x, int y) {
        if (x < 0 || x >= SQUARE_WIDTH)
            return false;
 
        if (y < 0 || y >= SQUARE_WIDTH)
            return false;
 
        for (int i = x - 1; i <= x + 1; i++) {
            for (int j = y - 1; j <= y + 1; j++) {
                if (i == x && j == y) // it's myself, skip
                    continue;
 
                if (i != x && j != y)
                    continue;
 
                if (i < 0 || i >= SQUARE_WIDTH)
                    continue;
 
                if (j < 0 || j >= SQUARE_WIDTH)
                    continue;
 
                if (square[j * SQUARE_WIDTH + i] == 0)
                    return true;
            }
        }
 
        return false;
    }
 
    public Point move(int x, int y) {
        Log.d(TAG, "move" + ",x=" + x + ",y=" + y);
        if (!moveable(x, y))
            return new Point(-1, -1);
 
        steps++;
 
        for (int i = x - 1; i <= x + 1; i++) {
            for (int j = y - 1; j <= y + 1; j++) {
                if (i == x && j == y) // it's myself, skip
                    continue;
 
                if (i != x && j != y)
                    continue;
 
                if (i < 0 || i >= SQUARE_WIDTH)
                    continue;
 
                if (j < 0 || j >= SQUARE_WIDTH)
                    continue;
 
                if (square[j * SQUARE_WIDTH + i] == 0) {
                    int temp = square[j * SQUARE_WIDTH + i];
                    square[j * SQUARE_WIDTH + i] = square[y * SQUARE_WIDTH + x];
                    square[y * SQUARE_WIDTH + x] = temp;
                    return new Point(i, j);
                }
            }
        }
 
        return new Point(-1, -1);
    }
 
    public boolean win() {
        for (int i = 0; i < square.length - 1; i++) {
            if (square[i] != i + 1)
                return false;
        }
        return true;
    }
    
    public class Pic{
        private  int id;
        private  Bitmap subbitmap;
    }
}

MagicSquarView.java


package org.diudiululu.magicSquare;
 
import java.util.ArrayList;
 
import org.diudiululu.magicSquare.R;
 
import android.app.Dialog;
import android.content.Context;
import android.util.AttributeSet;
import android.util.Log;
import android.view.*;
import android.graphics.*;
import android.graphics.Paint.FontMetrics;
import android.graphics.Paint.Style;
import android.util.*;
 

public class MagicSquareView extends View {
    private static final String TAG = "MagicSquare";
    private final MagicSquareActivity magicSquareActivity;
 
    private float width;
    private float height;
    private int selX;
    private int selY;
    private final Rect selRect = new Rect();
    private final int pingtuheight = 200;
 
    private ArrayList<Pic> pieces;
 
    
    public MagicSquareView(Context context) {
        super(context);
        this.magicSquareActivity = (MagicSquareActivity) context;
        this.setFocusable(true);
        this.setFocusableInTouchMode(true);
        // TODO Auto-generated constructor stub
    }
 
    // 切割图片，放入ArrayList中
    {
        pieces = new ArrayList<MagicSquareView.Pic>();
        Bitmap bitmap = BitmapFactory.decodeResource(getResources(),
                R.drawable.pingtu);
        int bitmapwidth = bitmap.getWidth();
        int bitmapheight = bitmap.getHeight();
        int pieceWidth = bitmapwidth / 3;
        int pieceHeight = bitmapheight / 3;
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                Pic piece = new Pic();
                piece.index = j + i * 3;
                int xValue = j * pieceWidth;
                int yValue = i * pieceHeight;
                piece.piece = Bitmap.createBitmap(bitmap, xValue, yValue,
                        pieceWidth, pieceHeight);
                pieces.add(piece);
            }
        }
    }
 
    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
 
        width = w / 3f;
        height = (h - pingtuheight) / 3f;
        getRect(selX, selY, selRect);
        Log.d(TAG, "onSizeChanged: width=" + width + ", height=" + height
                + ",selX=" + selX + ",selY=" + selY);
        super.onSizeChanged(w, h, oldw, oldh);
    }
 
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        switch (keyCode) {
        case KeyEvent.KEYCODE_DPAD_UP:
            select(selX, selY - 1);
            break;
        case KeyEvent.KEYCODE_DPAD_DOWN:
            select(selX, selY + 1);
            break;
        case KeyEvent.KEYCODE_DPAD_LEFT:
            select(selX - 1, selY);
            break;
        case KeyEvent.KEYCODE_DPAD_RIGHT:
            select(selX + 1, selY);
            break;
        case KeyEvent.KEYCODE_ENTER:
        case KeyEvent.KEYCODE_DPAD_CENTER:
            Point point = magicSquareActivity.move(selX, selY);
            if (point.x >= 0 && point.y >= 0) {
                this.invalidate(selRect);
                Rect targetRect = new Rect();
                this.getRect(point.x, point.y, targetRect);
                this.invalidate(targetRect);
            }
            break;
        default:
            return super.onKeyDown(keyCode, event);
        }
        return true;
    }
 
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (event.getAction() != MotionEvent.ACTION_DOWN)
            return super.onTouchEvent(event);
        if (event.getY() <= pingtuheight)
            return false;
        Log.i(TAG,
                "event.getX()=" + event.getX() + ",event.getY=" + event.getY());
        select((int) (event.getX() / width),
                (int) ((event.getY() - pingtuheight) / height));
 
        Point point = magicSquareActivity.move(selX, selY);
        if (point.x >= 0 && point.y >= 0) {
            this.invalidate(selRect);
            Rect targetRect = new Rect();
            this.getRect(point.x, point.y, targetRect);
            this.invalidate(targetRect);
        }
        return true;
    }
 
    @Override
    protected void onDraw(Canvas canvas) {
        Paint backround = new Paint();
        backround.setColor(getResources().getColor(R.color.ms_backgroud));
        canvas.drawRect(0, 0, this.getWidth(), this.getHeight(), backround);
        // 画出原图及图片的介绍
        Rect dst = new Rect();// 屏幕 >>目标矩形
        Bitmap pic = BitmapFactory.decodeResource(getResources(),
                R.drawable.pingtu);
 
        dst.left = 0;
        dst.top = 0;
        dst.right = (int) (width * 3) / 2;
        dst.bottom = pingtuheight;
        canvas.drawBitmap(pic, null, dst, null);
        // 绘制出图片的介绍
        Paint textpaint = new Paint();
        textpaint.setTextSize(25);
        canvas.drawText("一副美丽的图片，", dst.right, 30, textpaint);
        canvas.drawText("但已支离破碎......", dst.right, 70, textpaint);
 
        // draw the board
        Paint dark = new Paint();
        dark.setColor(getResources().getColor(R.color.ms_dark));
 
        Paint hilite = new Paint();
        hilite.setColor(getResources().getColor(R.color.ms_hilite));
 
        Paint light = new Paint();
        light.setColor(getResources().getColor(R.color.ms_light));
 
        // draw the minor grid lines
        for (int i = 0; i < 3; i++) {
            canvas.drawLine(0, i * height + pingtuheight, getWidth(), i
                    * height + pingtuheight, light);
            canvas.drawLine(0, i * height + 1 + pingtuheight, getWidth(), i
                    * height + pingtuheight + 1, hilite);
            canvas.drawLine(i * width, pingtuheight, i * width, getHeight()
                    + pingtuheight, light);
            canvas.drawLine(i * width + 1, pingtuheight, i * width + 1,
                    getHeight() + pingtuheight, hilite);
        }
        Rect picrect = new Rect();
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
            int n = this.magicSquareActivity.getTitleNumber(i, j);//根据坐标依次取出0,1,2,3,4,5,6,7,8下标数组对应的值
                if (n == 0)
                    continue;
                picrect.left = (int) (i * width);
                picrect.top = pingtuheight + (int) (j * height);
                picrect.right = (int) (i * width + width);
                picrect.bottom = (int) (pingtuheight + j * height + height);
                canvas.drawBitmap(pieces.get(n).getPiece(), null, picrect, null);
 
            }
        }
 
        Paint selected = new Paint();
        selected.setColor(getResources().getColor(R.color.ms_selected));
        canvas.drawRect(selRect, selected);
 
        if (magicSquareActivity.win()) {
            Dialog winDlg = new Win(magicSquareActivity);
            winDlg.show();
            magicSquareActivity.finish();
        }
    }
 
    private void getRect(int x, int y, Rect rect) {
        Log.i(TAG, "getRect" + x + "y" + y);
        rect.set((int) (x * width), (int) (y * height + pingtuheight), (int) (x
                * width + width), (int) (y * height + height + pingtuheight));
    }
 
    private void select(int x, int y) {
        invalidate(selRect);
        selX = Math.min(Math.max(x, 0), 2);
        selY = Math.min(Math.max(y, 0), 2);
        getRect(selX, selY, selRect);
        invalidate(selRect);
    }
 
    public class Pic {
        public int getIndex() {
            return index;
        }
 
        public void setIndex(int index) {
            this.index = index;
        }
 
        public Bitmap getPiece() {
            return piece;
        }
 
        public void setPiece(Bitmap piece) {
            this.piece = piece;
        }
 
        int index;
        Bitmap piece;
    }
}