Android拼图游戏开发全纪录3

今天我们要继续开发Android游戏拼图，今天同样是做一些准备工作，昨天我们把界面的准备工作做好了，今天呢，我们想想，要完成一个拼图，我们还需要做哪些准备。

首先，我们需要一个工具类，去获取屏幕的相关信息，让我们的程序去自动适应不同分辨率大小的屏幕：

package com.xys.xpuzzle.util;

import android.content.Context;
import android.util.DisplayMetrics;
import android.view.Display;
import android.view.WindowManager;

/**
 * 屏幕工具类：实现获取屏幕相关参数
 *
 * @author xys
 *
 */
public class ScreenUtil {

    /**
     * 获取屏幕相关参数
     *
     * @param context
     * @return DisplayMetrics 屏幕宽高
     */
    public static DisplayMetrics getScreenSize(Context context) {
	DisplayMetrics metrics = new DisplayMetrics();
	WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
	Display display = wm.getDefaultDisplay();
	display.getMetrics(metrics);
	return metrics;
    }
}

下面我们要开始设计一个实体bean，去封装我们的拼图，这里的方法有很多，我只是举个砖头。

我们知道，拼图时会把图片分割成NXN个方块，移动方块以完成拼图，所以我将每个分割后的方块做成一个对象，我们所有的实体bean都是基于每个分割后的方块，所以自然的我们可以抽象出一个实体bean：

package com.xys.xpuzzle.bean;

import android.graphics.Bitmap;

/**
 * 拼图Item逻辑实体类：封装逻辑相关属性
 *
 * @author xys
 *
 */
public class ItemBean {

    // Item的Id
    private int itemId;
    // bitmap的Id
    private int bitmapId;
    // bitmap
    private Bitmap bitmap;

    public int getItemId() {
	return itemId;
    }

    public void setItemId(int itemId) {
	this.itemId = itemId;
    }

    public ItemBean() {
    }

    public int getBitmapId() {
	return bitmapId;
    }

    public void setBitmapId(int bitmapId) {
	this.bitmapId = bitmapId;
    }

    public Bitmap getBitmap() {
	return bitmap;
    }

    public void setBitmap(Bitmap bitmap) {
	this.bitmap = bitmap;
    }

    public ItemBean(int itemId, int bitmapId, Bitmap bitmap) {
	this.itemId = itemId;
	this.bitmapId = bitmapId;
	this.bitmap = bitmap;
    }

}

bean里面封装了

1、方块对应在NXN格中的序号

2、分割后的图片的ID和对应的图片

接下来就是对图片的分割：

package com.xys.xpuzzle.util;

import java.util.ArrayList;
import java.util.List;

import com.xys.xpuzzle.R;
import com.xys.xpuzzle.activity.PuzzleMain;
import com.xys.xpuzzle.bean.ItemBean;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;

/**
 * 图像工具类：实现图像的分割与自适应
 *
 * @author xys
 *
 */
public class ImagesUtil {

    public ItemBean itemBean;

    /**
     * 切图、初始状态（正常顺序）
     *
     * @param type
     * @param picSelected
     * @param context
     */
    public void createInitBitmaps(int type, Bitmap picSelected, Context context) {
	Bitmap bitmap = null;
	List<Bitmap> bitmapItems = new ArrayList<Bitmap>();
	// 每个Item的宽高
	int itemWidth = picSelected.getWidth() / type;
	int itemHeight = picSelected.getHeight() / type;
	for (int i = 1; i <= type; i++) {
	    for (int j = 1; j <= type; j++) {
		bitmap = Bitmap.createBitmap(picSelected, (j - 1) * itemWidth, (i - 1) * itemHeight, itemWidth, itemHeight);
		bitmapItems.add(bitmap);
		itemBean = new ItemBean((i - 1) * type + j, (i - 1) * type + j, bitmap);
		GameUtil.itemBeans.add(itemBean);
	    }
	}
	// 保存最后一个图片在拼图完成时填充
	PuzzleMain.lastBitmap = bitmapItems.get(type * type - 1);
	// 设置最后一个为空Item
	bitmapItems.remove(type * type - 1);
	GameUtil.itemBeans.remove(type * type - 1);
	Bitmap blankBitmap = BitmapFactory.decodeResource(context.getResources(), R.drawable.blank);
	blankBitmap = Bitmap.createBitmap(blankBitmap, 0, 0, itemWidth, itemHeight);

	bitmapItems.add(blankBitmap);
	GameUtil.itemBeans.add(new ItemBean(type * type, 0, blankBitmap));

	GameUtil.blankItemBean = GameUtil.itemBeans.get(type * type - 1);
    }

    /**
     * 处理图片 放大、缩小到合适位置
     *
     * @param newWidth
     * @param newHeight
     * @param bitmap
     * @return
     */
    public Bitmap resizeBitmap(float newWidth, float newHeight, Bitmap bitmap) {
	Matrix matrix = new Matrix();
	matrix.postScale(newWidth / bitmap.getWidth(), newHeight / bitmap.getHeight());
	Bitmap newBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
	return newBitmap;
    }
}

这个工具类主要完成这两件事：

1、切图、初始状态（正常顺序）

2、处理图片 放大、缩小到合适位置

根据上一篇讲的算法，我们需要将图片进行分割，然后生成一个切好图后的Items集合，当然，还要对要拼图的图片进行下大小的处理，因为我们除了有默认的图片，还可以自定义图片

图片工具类完成后，接下来我们就要在一个工具类中实现这些算法，同时还要做一些对游戏的封装：

package com.xys.xpuzzle.util;

import java.util.ArrayList;
import java.util.List;

import com.xys.xpuzzle.activity.PuzzleMain;
import com.xys.xpuzzle.bean.ItemBean;

/**
 * 拼图工具类：实现拼图的交换与生成算法
 *
 * @author xys
 *
 */
public class GameUtil {

    // 游戏信息单元格Bean
    public static List<ItemBean> itemBeans = new ArrayList<ItemBean>();
    // 空格单元格
    public static ItemBean blankItemBean = new ItemBean();

    /**
     * 判断点击的Item是否可移动
     *
     * @param position
     * @return 能否移动
     */
    public static boolean isMoveable(int position) {
	int type = PuzzleMain.type;
	// 获取空格Item
	int blankId = GameUtil.blankItemBean.getItemId() - 1;
	// 不同行 相差为type
	if (Math.abs(blankId - position) == type) {
	    return true;
	}
	// 相同行 相差为1
	if ((blankId / type == position / type) && Math.abs(blankId - position) == 1) {
	    return true;
	}
	return false;
    }

    /**
     * 交换空格与点击Item的位置
     *
     * @param from
     * @param blank
     */
    public static void swapItems(ItemBean from, ItemBean blank) {
	ItemBean tempItemBean = new ItemBean();
	// 交换BitmapId
	tempItemBean.setBitmapId(from.getBitmapId());
	from.setBitmapId(blank.getBitmapId());
	blank.setBitmapId(tempItemBean.getBitmapId());
	// 交换Bitmap
	tempItemBean.setBitmap(from.getBitmap());
	from.setBitmap(blank.getBitmap());
	blank.setBitmap(tempItemBean.getBitmap());
	// 设置新的Blank
	GameUtil.blankItemBean = from;
    }

    /**
     * 生成随机的Item
     */
    public static void getPuzzleGenerator() {
	int index = 0;
	for (int i = 0; i < itemBeans.size(); i++) {
	    index = (int) (Math.random() * PuzzleMain.type * PuzzleMain.type);
	    swapItems(itemBeans.get(index), GameUtil.blankItemBean);
	}
	List<Integer> data = new ArrayList<Integer>();
	for (int i = 0; i < itemBeans.size(); i++) {
	    data.add(itemBeans.get(i).getBitmapId());
	}
	// 判断生成是否有解
	if (canSolve(data)) {
	    return;
	} else {
	    getPuzzleGenerator();
	}
    }

    /**
     * 是否拼图成功
     *
     * @return 是否拼图成功
     */
    public static boolean isSuccess() {
	for (ItemBean tempBean : GameUtil.itemBeans) {
	    if (tempBean.getBitmapId() != 0 && (tempBean.getItemId()) == tempBean.getBitmapId()) {
		continue;
	    } else if (tempBean.getBitmapId() == 0 && tempBean.getItemId() == PuzzleMain.type * PuzzleMain.type) {
		continue;
	    } else {
		return false;
	    }
	}
	return true;
    }

    /**
     * 该数据是否有解
     *
     * @param data
     * @return 该数据是否有解
     */
    public static boolean canSolve(List<Integer> data) {
	// 获取空格Id
	int blankId = GameUtil.blankItemBean.getItemId();
	// 可行性原则
	if (data.size() % 2 == 1) {
	    return getInversions(data) % 2 == 0;
	} else {
	    // 从底往上数,空格位于奇数行
	    if (((int) (blankId - 1) / PuzzleMain.type) % 2 == 1) {
		return getInversions(data) % 2 == 0;
	    } else {
		// 从底往上数,空位位于偶数行
		return getInversions(data) % 2 == 1;
	    }
	}
    }

    /**
     * 计算倒置和算法
     *
     * @param data
     * @return 该序列的倒置和
     */
    public static int getInversions(List<Integer> data) {
	int inversions = 0;
	int inversionCount = 0;
	for (int i = 0; i < data.size(); i++) {
	    for (int j = i + 1; j < data.size(); j++) {
		int index = data.get(i);
		if (data.get(j) != 0 && data.get(j) < index) {
		    inversionCount++;
		}
	    }
	    inversions += inversionCount;
	    inversionCount = 0;
	}
	return inversions;
    }
}

可以看到，游戏工具类中，我们主要有以下几个功能：

1、判断点击的Item是否可移动：主要难点是判断需要分同行与不同行，否则会出现上一行的最后一个和本行的第一个可以移动的BUG

2、交换空格与点击Item的位置：实际上是交换GridView中的某2个Item的背景

3、生成随机的Item：根据上一篇讲的算法，打随机打乱分割后的图片

4、判断是否拼图成功：根据上一篇讲的算法的结论判断

5、判断该数据是否有解：根据上一篇讲的算法的结论判断

6、计算倒置和算法：算法的核心注意要踢出空格

到目前为止，我们的准备工作就基本结束了，很多人可能会说开始的时候准备这么多干嘛，其实这是我真实的思考顺序，刚开始项目的时候，一定要先把项目整体规划一下，而不是上手就做，当你有了一个清晰的思路后，coding只是一个体力活而已。所以，工欲善其事，必先利其器，画竹需要成竹在胸。

ps ： 需要源码的朋友请留言。