项目开发-疯狂连连看游戏开发

疯狂连连看游戏开发

游戏简介：疯狂连连看，是一款简单易玩的手机休闲游戏，界面布局简单，玩法简单，适合广大年龄层的用户进行休闲、放松。该游戏，应用于Android手机操作系统，Android1.6以上。

游戏开发过程总结说明

==>>>游戏开发环境

操作系统：Win7 32位操作系统

处理器：Intel(R) Pentium(R)CPU 海尔P6000笔记本电脑

内存：2GB

==>>>游戏开发工具、软件

Eclipse软件，插件ADT，SDK Android 2.3.3版本

==>>>游戏功能

可以随机切换不同方向的连连看排列，增加可玩性，时间在100s内，在规定实践内消除所有方块，就可以赢得游戏，在规定时间没能消除所有方块，游戏失败。

==>>>游戏运行环境

Android手机操作系统，本人的是Motorala MB508,操作系统版本是Android 2.3.7 最稳定的一个版本

==>>>项目说明

项目名称：Link

项目大小：1.40MB

项目开发思维导图 凸^-^凸 本人刚接触思维导图，简单做了这个游戏的思维导图

==>>>项目开发5大块

第一part：开发游戏界面

第二part：连连看的数据模型

第三part：加载界面的图片

第四part：实现游戏Activity

第五part：实现游戏逻辑

第一part思维导图截图：

第二part思维导图截图：

第三part思维导图截图：

第四part思维导图截图：

第五part思维导图截图：

==>>>项目代码说明

第一块：开发游戏界面

1.开发界面布局

布局代码：main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent" 
    android:background="@drawable/room"
    >
    <!-- 游戏主界面的自定义组件 -->
    <org.wwj.link.view.GameView
        android:id="@+id/gameView"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        />
    <!-- 水平排列的LinearLayout -->
    <LinearLayout 
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="horizontal"
        android:layout_marginTop="380px"
        android:background="#1e72bb"
        android:gravity="center">
        <!-- 控制游戏开始的按钮 -->
        <Button
            android:id="@+id/startButton"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:background="@drawable/button_selector"/>
        <!-- 显示游戏剩余时间的文本框 -->
        <TextView 
            android:id="@+id/timeText"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:gravity="center"
            android:textSize="20dip"
            android:width="150px"
            android:textColor="#ff9"/>"
    </LinearLayout>
</RelativeLayout>

指定按钮的背景色使用@drawable/button_selector

==>>button_selector.xml

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android" >
    <!-- 指定按钮按下时的图片 -->
    <item android:state_pressed="true"
        android:drawable="@drawable/start_down"/>
    <!-- 指定按钮松开的图片 -->
    <item android:state_pressed="false"
        android:drawable="@drawable/start"
        />
</selector>

效果图：

2.开发游戏界面组件

上面的布局文件用到了自顶义的View:GameView,它从View基类派生而出，这个自定义View的功能就是游戏状态来绘制游戏界面上的全部方块。

在实现GameView之前，要为它提供一个Piece类，一个Piece对象代表游戏界面上的一个方块。

==>>Piece.java

package org.wwj.link.view;

import android.graphics.Point;

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

	// 只设置该Piece对象在数组中的索引值
	public Piece(int indexX , int indexY)
	{
		this.indexX = indexX;
		this.indexY = indexY;
	}
	//获得该方块的左上角的x坐标
	public int getBeginX()
	{
		return beginX;
	}
	//设置方块的左上角的x坐标
	public void setBeginX(int beginX)
	{
		this.beginX = beginX;
	}
	//获取该方块的做上角的y坐标
	public int getBeginY()
	{
		return beginY;
	}
	//设置方块的左上角的y坐标
	public void setBeginY(int beginY)
	{
		this.beginY = beginY;
	}
	//获取方块的第一维的索引值
	public int getIndexX()
	{
		return indexX;
	}
	//设置方块的第一维的索引值
	public void setIndexX(int indexX)
	{
		this.indexX = indexX;
	}
	//获取方块的第二维的索引值
	public int getIndexY()
	{
		return indexY;
	}
	//设置方块的第二维的索引值
	public void setIndexY(int indexY)
	{
		this.indexY = indexY;
	}
	//获取图片对象
	public PieceImage getImage()
	{
		return image;
	}
	//设置图片对象
	public void setImage(PieceImage image)
	{
		this.image = image;
	}

	// 获取该Piece的中心
	public Point getCenter()
	{	
		//Piece对象的中心是该图片的宽高+该图片对应的左上角的x、y坐标
		return new Point(getImage().getImage().getWidth() / 2
			+ getBeginX(), getBeginY()
			+ getImage().getImage().getHeight() / 2);
	}	
	// 判断两个Piece上的图片是否相同
	public boolean isSameImage(Piece other)
	{
		if (image == null)
		{
			if (other.image != null)
				return false;
		}
		// 只要Piece封装图片ID相同，即可认为两个Piece相等。
		return image.getImageId() == other.image.getImageId();
	}
}

上面的Piece类中封装的PieceImage代表了该方块上的图片，PieceImage封装了两个信息：

>> Bitmap对象

>> 图片资源的ID

==>>PieceImage.java

package org.wwj.link.view;

import android.graphics.Bitmap;

/*
 * 使用PieceImage来封装两个信息：
 * =>Bitmap对象
 * =>图片资源的ID
 */
public class PieceImage
{
	private Bitmap image;
	private int imageId;
	// 有参数的构造器
	public PieceImage(Bitmap image, int imageId)
	{
		super();
		this.image = image;
		this.imageId = imageId;
	}
	public Bitmap getImage()
	{
		return image;
	}
	public void setImage(Bitmap image)
	{
		this.image = image;
	}
	public int getImageId()
	{
		return imageId;
	}
	public void setImageId(int imageId)
	{
		this.imageId = imageId;
	}
}

GameView主要就是根据游戏的状态数据来绘制界面上的方块，GameView继承View组件，重写了View组件上onDraw(Canvas canvas)方法，重写该方法主要是绘制游戏里剩余的方块；除此之外，它还会负责绘制连接方块的连接线。

程序当中用到的GameService类、LinkInfo类主要在后面实现
==>>GameView.java

package org.wwj.link.view;

import java.util.List;

import org.wwj.link.board.GameService;
import org.wwj.link.object.LinkInfo;
import org.wwj.link.util.ImageUtil;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Point;
import android.util.AttributeSet;
import android.view.View;

public class GameView extends View
{
	// 游戏逻辑的实现类
	private GameService gameService;
	// 保存当前已经被选中的方块
	private Piece selectedPiece;
	// 连接信息对象
	private LinkInfo linkInfo;
	private Paint paint;
	// 选中标识的图片对象
	private Bitmap selectImage;

	public GameView(Context context, AttributeSet attrs)
	{
		super(context, attrs);
		this.paint = new Paint();
		// 设置连接线的颜色
		this.paint.setColor(Color.RED);
		// 设置连接线的粗细
		this.paint.setStrokeWidth(3);
		// 利用ImageUtil工具类，获取选中标识的图片
		this.selectImage = ImageUtil.getSelectImage(context);
	}

	public void setLinkInfo(LinkInfo linkInfo)
	{
		this.linkInfo = linkInfo;
	}

	public void setGameService(GameService gameService)
	{
		this.gameService = gameService;
	}

	@Override
	protected void onDraw(Canvas canvas)
	{
		super.onDraw(canvas);
		if (this.gameService == null)
			return;
		Piece[][] pieces = gameService.getPieces();
		if (pieces != null)
		{
			// 遍历pieces二维数组
			for (int i = 0; i < pieces.length; i++)
			{
				for (int j = 0; j < pieces[i].length; j++)
				{
					// 如果二维数组中该元素不为空（即有方块），将这个方块的图片画出来
					if (pieces[i][j] != null)
					{
						// 得到这个Piece对象
						Piece piece = pieces[i][j];
						// 根据方块左上角X、Y座标绘制方块
						canvas.drawBitmap(piece.getImage().getImage(),
							piece.getBeginX(), piece.getBeginY(), null);
					}
				}
			}
		}
		// 如果当前对象中有linkInfo对象, 即连接信息
		if (this.linkInfo != null)
		{
			// 绘制连接线
			drawLine(this.linkInfo, canvas);
			// 处理完后清空linkInfo对象
			this.linkInfo = null;
		}
		// 画选中标识的图片
		if (this.selectedPiece != null)
		{
			canvas.drawBitmap(this.selectImage, this.selectedPiece.getBeginX(),
				this.selectedPiece.getBeginY(), null);
		}
	}

	// 根据LinkInfo绘制连接线的方法。
	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);
		}
	}

	// 设置当前选中方块的方法
	public void setSelectedPiece(Piece piece)
	{
		this.selectedPiece = piece;
	}

	// 开始游戏方法
	public void startGame()
	{
		this.gameService.start();
		//重绘
		this.postInvalidate();
	}
}

3.处理方块之间的连接线

LinkInfo是一个非常实用的工具类，它用于封装两个方块之间的连接信息--其实就是封装了一个List，List里保存了连接线需要经过的点。

它包括三个构造器，分别处理没有拐点，一个拐点，两个拐点的情况。

==>>LinkInfo.java

package org.wwj.link.object;

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

import android.graphics.Point;

public class LinkInfo
{
	// 创建一个集合用于保存连接点
	private List<Point> points = new ArrayList<Point>();

	// 提供第一个构造器, 表示两个Point可以直接相连, 没有转折点
	public LinkInfo(Point p1, Point p2)
	{
		// 加到集合中去
		points.add(p1);
		points.add(p2);
	}

	// 提供第二个构造器, 表示三个Point可以相连, p2是p1与p3之间的转折点
	public LinkInfo(Point p1, Point p2, Point p3)
	{
		points.add(p1);
		points.add(p2);
		points.add(p3);
	}

	// 提供第三个构造器, 表示四个Point可以相连, p2, p3是p1与p4的转折点
	public LinkInfo(Point p1, Point p2, Point p3, Point p4)
	{
		points.add(p1);
		points.add(p2);
		points.add(p3);
		points.add(p4);
	}

	// 返回连接集合
	public List<Point> getLinkPoints()
	{
		return points;
	}
}

第二块：连连看的状态数据模型

1.定义数据模型

建立数据模型是实现游戏逻辑的一个重要部分，首先我们需要把游戏的数据模型给定义出来，连连看的游戏界面是一个N x M的“网格”,每个网格上显示一张图片。

我们开发的这个连连看游戏就是一个6 x 7的网格，一共42张图片，这就是我们定义的数据模型。我们用什么来保存游戏的状态模型呢？就是之前定义的Piece类，定义一个Piece[][]二维数组来保存，因为Piece对象封装的信息更多，包含了方块的左上角的X、Y坐标，而且还包含了该Piece所显示的图片、图片ID等。

2.初始化游戏状态数据

定义一个抽象类AbstractBoard,作为一个模板，让子类去实现相应的抽象方法。

==>>AbstractBoard.java

package org.wwj.link.board;

import java.util.List;

import org.wwj.link.object.GameConf;
import org.wwj.link.util.ImageUtil;
import org.wwj.link.view.Piece;
import org.wwj.link.view.PieceImage;

public abstract class AbstractBoard
{
	// 定义一个抽象方法, 让子类去实现
	protected abstract List<Piece> createPieces(GameConf config,
		Piece[][] pieces);

	public Piece[][] create(GameConf config)
	{
		// 创建Piece[][]数组
		Piece[][] pieces = new Piece[config.getXSize()][config.getYSize()];
		// 返回非空的Piece集合, 该集合由子类去创建
		List<Piece> notNullPieces = createPieces(config, pieces);
		// 根据非空Piece对象的集合的大小来取图片
		List<PieceImage> playImages = ImageUtil.getPlayImages(config.getContext(),
			notNullPieces.size());
		// 所有图片的宽、高都是相同的
		int imageWidth = playImages.get(0).getImage().getWidth();
		int imageHeight = playImages.get(0).getImage().getHeight();
		// 遍历非空的Piece集合
		for (int i = 0; i < notNullPieces.size(); i++)
		{
			// 依次获取每个Piece对象
			Piece piece = notNullPieces.get(i);
			piece.setImage(playImages.get(i));
			// 计算每个方块左上角的X、Y座标
			piece.setBeginX(piece.getIndexX() * imageWidth
				+ config.getBeginImageX());
			piece.setBeginY(piece.getIndexY() * imageHeight
				+ config.getBeginImageY());
			// 将该方块对象放入方块数组的相应位置处
			pieces[piece.getIndexX()][piece.getIndexY()] = piece;
		}
		return pieces;
	}
}

下面为AbstractBoard实现的3个子类

1.矩阵排列的方块

效果如图：

==>>FullBoard.java

package org.wwj.link.board.impl;

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

import org.wwj.link.board.AbstractBoard;
import org.wwj.link.object.GameConf;
import org.wwj.link.view.Piece;

public class FullBoard extends AbstractBoard
{
	@Override
	protected List<Piece> createPieces(GameConf config,
		Piece[][] pieces)
	{
		// 创建一个Piece集合, 该集合里面存放初始化游戏时所需的Piece对象
		List<Piece> notNullPieces = new ArrayList<Piece>();
		for (int i = 1; i < pieces.length - 1; i++)
		{
			for (int j = 1; j < pieces[i].length - 1; j++)
			{
				// 先构造一个Piece对象, 只设置它在Piece[][]数组中的索引值，
				// 所需要的PieceImage由其父类负责设置。
				Piece piece = new Piece(i, j);
				// 添加到Piece集合中
				notNullPieces.add(piece);
			}
		}
		return notNullPieces;
	}
}

2.竖向排列的方块

效果图：

==>>VerticalBoard.java

package org.wwj.link.board.impl;

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

import org.wwj.link.board.AbstractBoard;
import org.wwj.link.object.GameConf;
import org.wwj.link.view.Piece;

public class VerticalBoard extends AbstractBoard
{
	protected List<Piece> createPieces(GameConf config,
		Piece[][] pieces)
	{
		// 创建一个Piece集合, 该集合里面存放初始化游戏时所需的Piece对象
		List<Piece> notNullPieces = new ArrayList<Piece>();
		for (int i = 0; i < pieces.length; i++)
		{
			for (int j = 0; j < pieces[i].length; j++)
			{
				// 加入判断, 符合一定条件才去构造Piece对象, 并加到集合中
				if (i % 2 == 0)
				{
					// 如果x能被2整除, 即单数列不会创建方块
					// 先构造一个Piece对象, 只设置它在Piece[][]数组中的索引值，
					// 所需要的PieceImage由其父类负责设置。
					Piece piece = new Piece(i, j);
					// 添加到Piece集合中
					notNullPieces.add(piece);
				}
			}
		}
		return notNullPieces;
	}
}

3.横向排列的方块

效果图：

第三块：加载界面的图片

这也是一个工具类：ImageUtil,用于加载程序界面上所需的图片

程序的实现思路可以分为4步：

1.通过反射来获取R.drawable的所有Field（Android的每张图片资源都会自动转换为R.drawable的静态Field），并将这些Field值田间到一个List集合中。

2.从第一步得到的List集合中随机“抽取”N/2个图片ID。

3.将第二步得到的N/2个图片ID全部复制一份，这样就得到了N个图片ID，而且每个图片ID都可以找到与之配对的。

4.将第三步得到的N个图片ID再次“随机打乱”，并根据图片ID加载对应的Bitmap对象，最后把图片ID及对应的Bitmap封装成PieceImage后返回。

package org.wwj.link.util;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

import org.wwj.link.Activity.R;
import org.wwj.link.view.PieceImage;

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

public class ImageUtil
{
	// 保存所有连连看图片资源值(int类型)
	private static List<Integer> imageValues = getImageValues();

	//获取连连看所有图片的ID（约定所有图片ID以p_开头）
	public static List<Integer> getImageValues()
	{
		try
		{
			// 得到R.drawable所有的属性, 即获取drawable目录下的所有图片
			Field[] drawableFields = R.drawable.class.getFields();
			List<Integer> resourceValues = new ArrayList<Integer>();
			for (Field field : drawableFields)
			{
				// 如果该Field的名称以p_开头
				if (field.getName().indexOf("p_") != -1)
				{
					resourceValues.add(field.getInt(R.drawable.class));
				}
			}
			return resourceValues;
		}
		catch (Exception e)
		{
			return null;
		}
	}

	/**
	 * 随机从sourceValues的集合中获取size个图片ID, 返回结果为图片ID的集合
	 * 
	 * @param sourceValues 从中获取的集合
	 * @param size 需要获取的个数
	 * @return size个图片ID的集合
	 */
	public static List<Integer> getRandomValues(List<Integer> sourceValues,
		int size)
	{
		// 创建一个随机数生成器
		Random random = new Random();
		// 创建结果集合
		List<Integer> result = new ArrayList<Integer>();
		for (int i = 0; i < size; i++)
		{
			try
			{
				// 随机获取一个数字，大于、小于sourceValues.size()的数值
				int index = random.nextInt(sourceValues.size());
				// 从图片ID集合中获取该图片对象
				Integer image = sourceValues.get(index);
				// 添加到结果集中
				result.add(image);
			}
			catch (IndexOutOfBoundsException e)
			{
				return result;
			}
		}
		return result;
	}

	/**
	 * 从drawable目录中中获取size个图片资源ID(以p_为前缀的资源名称), 其中size为游戏数量
	 * 
	 * @param size 需要获取的图片ID的数量
	 * @return size个图片ID的集合
	 */
	public static List<Integer> getPlayValues(int size)
	{
		if (size % 2 != 0)
		{
			// 如果该数除2有余数，将size加1
			size += 1;
		}
		// 再从所有的图片值中随机获取size的一半数量
		List<Integer> playImageValues = getRandomValues(imageValues, size / 2);
		// 将playImageValues集合的元素增加一倍（保证所有图片都有与之配对的图片）
		playImageValues.addAll(playImageValues);
		// 将所有图片ID随机“洗牌”
		Collections.shuffle(playImageValues);
		return playImageValues;
	}

	/**
	 * 将图片ID集合转换PieceImage对象集合，PieceImage封装了图片ID与图片本身
	 * 
	 * @param context
	 * @param resourceValues
	 * @return size个PieceImage对象的集合
	 */
	public static List<PieceImage> getPlayImages(Context context, int size)
	{
		// 获取图片ID组成的集合
		List<Integer> resourceValues = getPlayValues(size);
		List<PieceImage> result = new ArrayList<PieceImage>();
		// 遍历每个图片ID
		for (Integer value : resourceValues)
		{
			// 加载图片
			Bitmap bm = BitmapFactory.decodeResource(
				context.getResources(),  value);
			// 封装图片ID与图片本身
			PieceImage pieceImage = new PieceImage(bm, value);
			result.add(pieceImage);
		}
		return result;
	}

	// 获取选中标识的图片
	public static Bitmap getSelectImage(Context context)
	{	
		//利用位图工场获取图片资源
		Bitmap bm = BitmapFactory.decodeResource(context.getResources(),
			R.drawable.selected);
		return bm;
	}
}

第四块：实现游戏逻辑

游戏逻辑是整个游戏开发过程中最复杂的部分，因为我们需要设计相应的算法来实现游戏的基本功能，如果不能对游戏有很透彻的分析，这部分将变得举步维艰。

首先定义一个业务逻辑类:GameService接口

package org.wwj.link.board;

import org.wwj.link.object.LinkInfo;
import org.wwj.link.view.Piece;
//负责游戏的逻辑实现
public interface GameService {
	/**
	 * 控制游戏的方法
	 */
	void start();
	/**
	 * 定义一个接口方法，用于返回一个二维数组
	 * @return 存放方块对象的二维数组
	 */
	Piece[][] getPieces();
	/**
	 * 判断参数Piece[][]数组中是否还存在非空的Piece对象
	 * @return 如果还剩下Pieces对象则返回true,没有则返回false
	 */
	boolean hasPieces();
	/**
	 * 根据鼠标的x坐标和y坐标，查找出一个Piece对象
	 * @param touchX 鼠标点击的x坐标
	 * @param touchY 鼠标点击的y坐标
	 * @return 返回对应的Piece对象，没有则返回null
	 */
	Piece findPiece(float touchX, float touchY);
	/**
	 * 判断两个Piece是否可以相连，如果可以相连，则返回LinkInfo对象
	 * @param p1  第一个Piece对象
	 * @param p2 第二个Piece对象
	 * @return 如果可以相连看，则返回LinkInfo对象，如果两个Piece不可以连接，返回null
	 */
	LinkInfo link(Piece p1, Piece p2);
}

实现GameService组件

这部分内容是整个项目开发最重要的部分，除了实现接口的方法，还需要实现游戏各种逻辑的情况，为了实现各种逻辑，还需要分治实现各种方法。

下面解析各种方法的作用：

start():初始化游戏状态，开始游戏的方法。

Piece[][] getPieces():返回游戏状态的Piece[][]数组

boolean hasPieces()：判断Piece[][]数组中是否还剩Piece对象；如果所有Piece都被消除了，游戏也就胜利了。

Piece findPiece(flaot touchX, float touchY):根据触碰点的X、Y坐标来获取。

LinkInfo link(Piece p1, Piece p2):判断p1、p2两个是否可以相连。

int getIndex(int relative, int size):工具方法，根据relative坐标计算相对于Piece[][]数组的第一维//或第二维的索引值。

List<Point> getLeftChanel(Point p, int min, int pieceWidth)：获取左边通道

List<Point> getRightChanel(Point p, int max, int pieceWidth): 获取右边通道

List<Point> getUpChanel(Point p, int min, int pieceHeight):获取上通道

List<Point> getDownChanel(Point p, int max, int pieceHeight):获取下通道

boolean isXBlock(Point p1, Point p2, int pieceWidth): 判断两个Y坐标相同的点对象之间是否有障碍。

boolean isYBlock(Point p1, Point p2, int pieceHeight): 判断两个X坐标相同的点对象之间是否有障碍。

Point getWrapPoint(List<Point> p1Chanel, List<Point> p2Chanel): 遍历两个通道，获取它们的交点。

Point getCornerrPoint(Point point1, Point point2, int pieceWidth, int pieceHeight): 获取两个不在同一行或者同一列的坐标点的直角连接点，即只有一个转折点。

boolean isLeftUp(Point p1,Point p2): 判断p2是否在p1的左上角。

boolean isLeftDown(Point p1, Point p2): 判断p2是否在p1的左下角。

boolean isRightUp(Point p1, Point p2): 判断p2是否p1的右上角。

boolean isRightDown(Point p1, Point p2): 判断p2是否在p1的右下角。

boolean hasPiece(int x, int y):判断GamePanel的X，Y坐标是否有Piece对象。

Map<Point,Point> getLinkPoints(Point point1, Point point2, int pieceWidth, int pieceHeight):获取两个转折点的情况。

Map<Point,Point> getYLinkPoints(List<Point> p1Chanel, List<Point> p2Chanel, int pieceHeight)

Map<Point,Point> getXLinkPoints(List<Point> p1Chanel, List<Point> p2Chanel, int pieceWidth)：用来收集各种可能出现的连接路径。

LinkInfo getShortCut(Point p1, Point p2, Map<Point, Point> turns, int shortDistance)：获取p1, p2之间最短的连接信息。

int countAll（List<Point> points）:计算List<Point>中所有点的距离总和。

int getDistance（Point p1, Point p2）：获取两个LinkPoint之间的最短距离。

package org.wwj.link.board.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

import org.wwj.link.board.AbstractBoard;
import org.wwj.link.board.GameService;
import org.wwj.link.object.GameConf;
import org.wwj.link.object.LinkInfo;
import org.wwj.link.view.Piece;

import android.graphics.Point;

public class GameServiceImpl implements GameService
{
	// 定义一个Piece[][]数组，只提供getter方法
	private Piece[][] pieces;
	// 游戏配置对象
	private GameConf config;

	public GameServiceImpl(GameConf config)
	{
		// 将游戏的配置对象设置本类中
		this.config = config;
	}

	public void start()
	{
		// 定义一个AbstractBoard对象
		AbstractBoard board = null;
		Random random = new Random();
		// 获取一个随机数, 可取值0、1、2、3四值。
		int index = random.nextInt(4);
		// 随机生成AbstractBoard的子类实例
		switch (index)
		{
			case 0:
				// 0返回VerticalBoard(竖向)
				board = new VerticalBoard();
				break;
			case 1:
				// 1返回HorizontalBoard(横向)
				board = new HorizontalBoard();
				break;
			default:
				// 默认返回FullBoard
				board = new FullBoard();
				break;
		}
		// 初始化Piece[][]数组
		this.pieces = board.create(config);
	}

	// 直接返回本对象的Piece[][]数组
	public Piece[][] getPieces()
	{
		return this.pieces;
	}

	// 实现接口的hasPieces方法
	public boolean hasPieces()
	{
		// 遍历Piece[][]数组的每个元素
		for (int i = 0; i < pieces.length; i++)
		{
			for (int j = 0; j < pieces[i].length; j++)
			{
				// 只要任意一个数组元素不为null，也就是还剩有非空的Piece对象
				if (pieces[i][j] != null)
				{
					return true;
				}
			}
		}
		return false;
	}

	// 根据触碰点的位置查找相应的方块
	public Piece findPiece(float touchX, float touchY)
	{
		// 由于在创建Piece对象的时候, 将每个Piece的开始座标加了
		// GameConf中设置的beginImageX/beginImageY值, 因此这里要减去这个值
		int relativeX = (int) touchX - this.config.getBeginImageX();
		int relativeY = (int) touchY - this.config.getBeginImageY();
		// 如果鼠标点击的地方比board中第一张图片的开始x座标和开始y座标要小, 即没有找到相应的方块
		if (relativeX < 0 || relativeY < 0)
		{
			return null;
		}
		// 获取relativeX座标在Piece[][]数组中的第一维的索引值
		// 第二个参数为每张图片的宽40
		int indexX = getIndex(relativeX, GameConf.PIECE_WIDTH);
		// 获取relativeY座标在Piece[][]数组中的第二维的索引值
		// 第二个参数为每张图片的高40
		int indexY = getIndex(relativeY, GameConf.PIECE_HEIGHT);
		// 这两个索引比数组的最小索引还小, 返回null
		if (indexX < 0 || indexY < 0)
		{
			return null;
		}
		// 这两个索引比数组的最大索引还大(或者等于), 返回null
		if (indexX >= this.config.getXSize()
			|| indexY >= this.config.getYSize())
		{
			return null;
		}
		// 返回Piece[][]数组的指定元素
		return this.pieces[indexX][indexY];
	}

	// 工具方法, 根据relative座标计算相对于Piece[][]数组的第一维
	// 或第二维的索引值 ，size为每张图片边的长或者宽
	private int getIndex(int relative, int size)
	{
		// 表示座标relative不在该数组中
		int index = -1;
		// 让座标除以边长, 没有余数, 索引减1
		// 例如点了x座标为20, 边宽为10, 20 % 10 没有余数,
		// index为1, 即在数组中的索引为1(第二个元素)
		if (relative % size == 0)
		{
			index = relative / size - 1;
		}
		else
		{
			// 有余数, 例如点了x座标为21, 边宽为10, 21 % 10有余数, index为2
			// 即在数组中的索引为2(第三个元素)
			index = relative / size;
		}
		return index;
	}
	
	// 实现接口的link方法
	public LinkInfo link(Piece p1, Piece p2)
	{
		// 两个Piece是同一个, 即选中了同一个方块, 返回null
		if (p1.equals(p2))
			return null;
		// 如果p1的图片与p2的图片不相同, 则返回null
		if (!p1.isSameImage(p2))
			return null;
		// 如果p2在p1的左边, 则需要重新执行本方法, 两个参数互换
		if (p2.getIndexX() < p1.getIndexX())
			return link(p2, p1);
		// 获取p1的中心点
		Point p1Point = p1.getCenter();
		// 获取p2的中心点
		Point p2Point = p2.getCenter();
		// 如果两个Piece在同一行
		if (p1.getIndexY() == p2.getIndexY())
		{
			// 它们在同一行并可以相连
			if (!isXBlock(p1Point, p2Point, GameConf.PIECE_WIDTH))
			{
				return new LinkInfo(p1Point, p2Point);
			}
		}
		// 如果两个Piece在同一列
		if (p1.getIndexX() == p2.getIndexX())
		{
			if (!isYBlock(p1Point, p2Point, GameConf.PIECE_HEIGHT))
			{
				// 它们之间没有真接障碍, 没有转折点
				return new LinkInfo(p1Point, p2Point);
			}
		}
		// 有一个转折点的情况
		// 获取两个点的直角相连的点, 即只有一个转折点
		Point cornerPoint = getCornerPoint(p1Point, p2Point,
			GameConf.PIECE_WIDTH, GameConf.PIECE_HEIGHT);
		if (cornerPoint != null)
		{
			return new LinkInfo(p1Point, cornerPoint, p2Point);
		}
		// 该map的key存放第一个转折点, value存放第二个转折点,
		// map的size()说明有多少种可以连的方式
		Map<Point, Point> turns = getLinkPoints(p1Point, p2Point,
			GameConf.PIECE_WIDTH, GameConf.PIECE_WIDTH);
		if (turns.size() != 0)
		{
			return getShortcut(p1Point, p2Point, turns,
				getDistance(p1Point, p2Point));
		}
		return null;
	}

	/**
	 * 获取两个转折点的情况
	 * @param point1
	 * @param point2
	 * @return Map对象的每个key-value对代表一种连接方式，
	 *   其中key、value分别代表第1个、第2个连接点
	 */
	private Map<Point, Point> getLinkPoints(Point point1, Point point2,
		int pieceWidth, int pieceHeight)
	{
		Map<Point, Point> result = new HashMap<Point, Point>();
		// 获取以point1为中心的向上, 向右, 向下的通道
		List<Point> p1UpChanel = getUpChanel(point1, point2.y, pieceHeight);
		List<Point> p1RightChanel = getRightChanel(point1, point2.x, pieceWidth);
		List<Point> p1DownChanel = getDownChanel(point1, point2.y, pieceHeight);
		// 获取以point2为中心的向下, 向左, 向上的通道
		List<Point> p2DownChanel = getDownChanel(point2, point1.y, pieceHeight);
		List<Point> p2LeftChanel = getLeftChanel(point2, point1.x, pieceWidth);
		List<Point> p2UpChanel = getUpChanel(point2, point1.y, pieceHeight);
		// 获取Board的最大高度
		int heightMax = (this.config.getYSize() + 1) * pieceHeight
			+ this.config.getBeginImageY();
		// 获取Board的最大宽度
		int widthMax = (this.config.getXSize() + 1) * pieceWidth
			+ this.config.getBeginImageX();
		// 先确定两个点的关系
		// point2在point1的左上角或者左下角
		if (isLeftUp(point1, point2) || isLeftDown(point1, point2))
		{
			// 参数换位, 调用本方法
			return getLinkPoints(point2, point1, pieceWidth, pieceHeight);
		}
		// p1、p2位于同一行不能直接相连
		if (point1.y == point2.y)
		{
			// 在同一行
			// 向上遍历
			// 以p1的中心点向上遍历获取点集合
			p1UpChanel = getUpChanel(point1, 0, pieceHeight);
			// 以p2的中心点向上遍历获取点集合
			p2UpChanel = getUpChanel(point2, 0, pieceHeight);
			Map<Point, Point> upLinkPoints = getXLinkPoints(p1UpChanel,
				p2UpChanel, pieceHeight);
			// 向下遍历, 不超过Board(有方块的地方)的边框
			// 以p1中心点向下遍历获取点集合
			p1DownChanel = getDownChanel(point1, heightMax, pieceHeight);
			// 以p2中心点向下遍历获取点集合
			p2DownChanel = getDownChanel(point2, heightMax, pieceHeight);
			Map<Point, Point> downLinkPoints = getXLinkPoints(p1DownChanel,
				p2DownChanel, pieceHeight);
			result.putAll(upLinkPoints);
			result.putAll(downLinkPoints);
		}
		// p1、p2位于同一列不能直接相连
		if (point1.x == point2.x)
		{
			// 在同一列
			// 向左遍历
			// 以p1的中心点向左遍历获取点集合
			List<Point> p1LeftChanel = getLeftChanel(point1, 0, pieceWidth);
			// 以p2的中心点向左遍历获取点集合
			p2LeftChanel = getLeftChanel(point2, 0, pieceWidth);
			Map<Point, Point> leftLinkPoints = getYLinkPoints(p1LeftChanel,
				p2LeftChanel, pieceWidth);
			// 向右遍历, 不得超过Board的边框（有方块的地方）
			// 以p1的中心点向右遍历获取点集合
			p1RightChanel = getRightChanel(point1, widthMax, pieceWidth);
			// 以p2的中心点向右遍历获取点集合
			List<Point> p2RightChanel = getRightChanel(point2, widthMax,
				pieceWidth);
			Map<Point, Point> rightLinkPoints = getYLinkPoints(p1RightChanel,
				p2RightChanel, pieceWidth);
			result.putAll(leftLinkPoints);
			result.putAll(rightLinkPoints);
		}
		// point2位于point1的右上角
		if (isRightUp(point1, point2))
		{		
			// 获取point1向上遍历, point2向下遍历时横向可以连接的点
			Map<Point, Point> upDownLinkPoints = getXLinkPoints(p1UpChanel,
				p2DownChanel, pieceWidth);
			// 获取point1向右遍历, point2向左遍历时纵向可以连接的点
			Map<Point, Point> rightLeftLinkPoints = getYLinkPoints(
				p1RightChanel, p2LeftChanel, pieceHeight);
			// 获取以p1为中心的向上通道
			p1UpChanel = getUpChanel(point1, 0, pieceHeight);
			// 获取以p2为中心的向上通道
			p2UpChanel = getUpChanel(point2, 0, pieceHeight);
			// 获取point1向上遍历, point2向上遍历时横向可以连接的点
			Map<Point, Point> upUpLinkPoints = getXLinkPoints(p1UpChanel,
				p2UpChanel, pieceWidth);
			// 获取以p1为中心的向下通道
			p1DownChanel = getDownChanel(point1, heightMax, pieceHeight);
			// 获取以p2为中心的向下通道
			p2DownChanel = getDownChanel(point2, heightMax, pieceHeight);
			// 获取point1向下遍历, point2向下遍历时横向可以连接的点
			Map<Point, Point> downDownLinkPoints = getXLinkPoints(p1DownChanel,
				p2DownChanel, pieceWidth);
			// 获取以p1为中心的向右通道
			p1RightChanel = getRightChanel(point1, widthMax, pieceWidth);
			// 获取以p2为中心的向右通道
			List<Point> p2RightChanel = getRightChanel(point2, widthMax,
				pieceWidth);
			// 获取point1向右遍历, point2向右遍历时纵向可以连接的点
			Map<Point, Point> rightRightLinkPoints = getYLinkPoints(
				p1RightChanel, p2RightChanel, pieceHeight);
			// 获取以p1为中心的向左通道
			List<Point> p1LeftChanel = getLeftChanel(point1, 0, pieceWidth);
			// 获取以p2为中心的向左通道
			p2LeftChanel = getLeftChanel(point2, 0, pieceWidth);
			// 获取point1向左遍历, point2向右遍历时纵向可以连接的点
			Map<Point, Point> leftLeftLinkPoints = getYLinkPoints(p1LeftChanel,
				p2LeftChanel, pieceHeight);
			result.putAll(upDownLinkPoints);
			result.putAll(rightLeftLinkPoints);
			result.putAll(upUpLinkPoints);
			result.putAll(downDownLinkPoints);
			result.putAll(rightRightLinkPoints);
			result.putAll(leftLeftLinkPoints);
		}
		// point2位于point1的右下角
		if (isRightDown(point1, point2))
		{
			// 获取point1向下遍历, point2向上遍历时横向可连接的点
			Map<Point, Point> downUpLinkPoints = getXLinkPoints(p1DownChanel,
				p2UpChanel, pieceWidth);
			// 获取point1向右遍历, point2向左遍历时纵向可连接的点
			Map<Point, Point> rightLeftLinkPoints = getYLinkPoints(
				p1RightChanel, p2LeftChanel, pieceHeight);
			// 获取以p1为中心的向上通道
			p1UpChanel = getUpChanel(point1, 0, pieceHeight);
			// 获取以p2为中心的向上通道
			p2UpChanel = getUpChanel(point2, 0, pieceHeight);
			// 获取point1向上遍历, point2向上遍历时横向可连接的点
			Map<Point, Point> upUpLinkPoints = getXLinkPoints(p1UpChanel,
				p2UpChanel, pieceWidth);
			// 获取以p1为中心的向下通道
			p1DownChanel = getDownChanel(point1, heightMax, pieceHeight);
			// 获取以p2为中心的向下通道
			p2DownChanel = getDownChanel(point2, heightMax, pieceHeight);
			// 获取point1向下遍历, point2向下遍历时横向可连接的点
			Map<Point, Point> downDownLinkPoints = getXLinkPoints(p1DownChanel,
				p2DownChanel, pieceWidth);
			// 获取以p1为中心的向左通道
			List<Point> p1LeftChanel = getLeftChanel(point1, 0, pieceWidth);
			// 获取以p2为中心的向左通道
			p2LeftChanel = getLeftChanel(point2, 0, pieceWidth);
			// 获取point1向左遍历, point2向左遍历时纵向可连接的点
			Map<Point, Point> leftLeftLinkPoints = getYLinkPoints(p1LeftChanel,
				p2LeftChanel, pieceHeight);
			// 获取以p1为中心的向右通道
			p1RightChanel = getRightChanel(point1, widthMax, pieceWidth);
			// 获取以p2为中心的向右通道
			List<Point> p2RightChanel = getRightChanel(point2, widthMax,
				pieceWidth);
			// 获取point1向右遍历, point2向右遍历时纵向可以连接的点
			Map<Point, Point> rightRightLinkPoints = getYLinkPoints(
				p1RightChanel, p2RightChanel, pieceHeight);
			result.putAll(downUpLinkPoints);
			result.putAll(rightLeftLinkPoints);
			result.putAll(upUpLinkPoints);
			result.putAll(downDownLinkPoints);
			result.putAll(leftLeftLinkPoints);
			result.putAll(rightRightLinkPoints);
		}
		return result;
	}
	
	/**
	 * 获取p1和p2之间最短的连接信息
	 * 
	 * @param p1
	 * @param p2
	 * @param turns 放转折点的map
	 * @param shortDistance 两点之间的最短距离
	 * @return p1和p2之间最短的连接信息
	 */
	private LinkInfo getShortcut(Point p1, Point p2, Map<Point, Point> turns,
		int shortDistance)
	{
		List<LinkInfo> infos = new ArrayList<LinkInfo>();
		// 遍历结果Map,
		for (Point point1 : turns.keySet())
		{
			Point point2 = turns.get(point1);
			// 将转折点与选择点封装成LinkInfo对象, 放到List集合中
			infos.add(new LinkInfo(p1, point1, point2, p2));
		}
		return getShortcut(infos, shortDistance);
	}
	
	/**
	 * 从infos中获取连接线最短的那个LinkInfo对象
	 * 
	 * @param infos
	 * @return 连接线最短的那个LinkInfo对象
	 */
	private LinkInfo getShortcut(List<LinkInfo> infos, int shortDistance)
	{
		int temp1 = 0;
		LinkInfo result = null;
		for (int i = 0; i < infos.size(); i++)
		{
			LinkInfo info = infos.get(i);
			// 计算出几个点的总距离
			int distance = countAll(info.getLinkPoints());
			// 将循环第一个的差距用temp1保存
			if (i == 0)
			{
				temp1 = distance - shortDistance;
				result = info;
			}
			// 如果下一次循环的值比temp1的还小, 则用当前的值作为temp1
			if (distance - shortDistance < temp1)
			{
				temp1 = distance - shortDistance;
				result = info;
			}
		}
		return result;
	}
	
	/**
	 * 计算List<Point>中所有点的距离总和
	 * 
	 * @param points 需要计算的连接点
	 * @return 所有点的距离的总和
	 */
	private int countAll(List<Point> points)
	{
		int result = 0;
		for (int i = 0; i < points.size() - 1; i++)
		{
			// 获取第i个点
			Point point1 = points.get(i);
			// 获取第i + 1个点
			Point point2 = points.get(i + 1);
			// 计算第i个点与第i + 1个点的距离，并添加到总距离中
			result += getDistance(point1, point2);
		}
		return result;
	}
	
	/**
	 * 获取两个LinkPoint之间的最短距离
	 * 
	 * @param p1 第一个点
	 * @param p2 第二个点
	 * @return 两个点的距离距离总和
	 */
	private int getDistance(Point p1, Point p2)
	{
		int xDistance = Math.abs(p1.x - p2.x);
		int yDistance = Math.abs(p1.y - p2.y);
		return xDistance + yDistance;
	}
	
	/**
	 * 遍历两个集合, 先判断第一个集合的元素的x座标与另一个集合中的元素x座标相同(纵向), 
	 * 如果相同, 即在同一列, 再判断是否有障碍, 没有则加到结果的Map中去
	 * 
	 * @param p1Chanel
	 * @param p2Chanel
	 * @param pieceHeight
	 * @return
	 */
	private Map<Point, Point> getYLinkPoints(List<Point> p1Chanel,
		List<Point> p2Chanel, int pieceHeight)
	{
		Map<Point, Point> result = new HashMap<Point, Point>();
		for (int i = 0; i < p1Chanel.size(); i++)
		{
			Point temp1 = p1Chanel.get(i);
			for (int j = 0; j < p2Chanel.size(); j++)
			{
				Point temp2 = p2Chanel.get(j);
				// 如果x座标相同(在同一列)
				if (temp1.x == temp2.x)
				{
					// 没有障碍, 放到map中去
					if (!isYBlock(temp1, temp2, pieceHeight))
					{
						result.put(temp1, temp2);
					}
				}
			}
		}
		return result;
	}
	
	/**
	 * 遍历两个集合, 先判断第一个集合的元素的y座标与另一个集合中的元素y座标相同(横向),
	 * 如果相同, 即在同一行, 再判断是否有障碍, 没有 则加到结果的map中去
	 * 
	 * @param p1Chanel
	 * @param p2Chanel
	 * @param pieceWidth
	 * @return 存放可以横向直线连接的连接点的键值对
	 */
	private Map<Point, Point> getXLinkPoints(List<Point> p1Chanel,
		List<Point> p2Chanel, int pieceWidth)
	{
		Map<Point, Point> result = new HashMap<Point, Point>();
		for (int i = 0; i < p1Chanel.size(); i++)
		{
			// 从第一通道中取一个点
			Point temp1 = p1Chanel.get(i);
			// 再遍历第二个通道, 看下第二通道中是否有点可以与temp1横向相连
			for (int j = 0; j < p2Chanel.size(); j++)
			{
				Point temp2 = p2Chanel.get(j);
				// 如果y座标相同(在同一行), 再判断它们之间是否有直接障碍
				if (temp1.y == temp2.y)
				{
					if (!isXBlock(temp1, temp2, pieceWidth))
					{
						// 没有障碍则直接加到结果的map中
						result.put(temp1, temp2);
					}
				}
			}
		}
		return result;
	}

	/**
	 * 判断point2是否在point1的左上角
	 * 
	 * @param point1
	 * @param point2
	 * @return p2位于p1的左上角时返回true，否则返回false
	 */
	private boolean isLeftUp(Point point1, Point point2)
	{
		return (point2.x < point1.x && point2.y < point1.y);
	}
	
	/**
	 * 判断point2是否在point1的左下角
	 * 
	 * @param point1
	 * @param point2
	 * @return p2位于p1的左下角时返回true，否则返回false
	 */
	private boolean isLeftDown(Point point1, Point point2)
	{
		return (point2.x < point1.x && point2.y > point1.y);
	}
	
	/**
	 * 判断point2是否在point1的右上角
	 * 
	 * @param point1
	 * @param point2
	 * @return p2位于p1的右上角时返回true，否则返回false
	 */
	private boolean isRightUp(Point point1, Point point2)
	{
		return (point2.x > point1.x && point2.y < point1.y);
	}
	
	/**
	 * 判断point2是否在point1的右下角
	 * 
	 * @param point1
	 * @param point2
	 * @return p2位于p1的右下角时返回true，否则返回false
	 */
	private boolean isRightDown(Point point1, Point point2)
	{
		return (point2.x > point1.x && point2.y > point1.y);
	}

	/**
	 * 获取两个不在同一行或者同一列的座标点的直角连接点, 即只有一个转折点
	 * 
	 * @param point1 第一个点
	 * @param point2 第二个点
	 * @return 两个不在同一行或者同一列的座标点的直角连接点
	 */
	private Point getCornerPoint(Point point1, Point point2, int pieceWidth,
		int pieceHeight)
	{
		// 先判断这两个点的位置关系
		// point2在point1的左上角, point2在point1的左下角
		if (isLeftUp(point1, point2) || isLeftDown(point1, point2))
		{
			// 参数换位, 重新调用本方法
			return getCornerPoint(point2, point1, pieceWidth, pieceHeight);
		}
		// 获取p1向右, 向上, 向下的三个通道
		List<Point> point1RightChanel = getRightChanel(point1, point2.x,
			pieceWidth);
		List<Point> point1UpChanel = getUpChanel(point1, point2.y, pieceHeight);
		List<Point> point1DownChanel = getDownChanel(point1, point2.y,
			pieceHeight);
		// 获取p2向下, 向左, 向上的三个通道
		List<Point> point2DownChanel = getDownChanel(point2, point1.y,
			pieceHeight);
		List<Point> point2LeftChanel = getLeftChanel(point2, point1.x,
			pieceWidth);
		List<Point> point2UpChanel = getUpChanel(point2, point1.y, pieceHeight);
		if (isRightUp(point1, point2))
		{
			// point2在point1的右上角
			// 获取p1向右和p2向下的交点
			Point linkPoint1 = getWrapPoint(point1RightChanel, point2DownChanel);
			// 获取p1向上和p2向左的交点
			Point linkPoint2 = getWrapPoint(point1UpChanel, point2LeftChanel);
			// 返回其中一个交点, 如果没有交点, 则返回null
			return (linkPoint1 == null) ? linkPoint2 : linkPoint1;
		}
		if (isRightDown(point1, point2))
		{
			// point2在point1的右下角
			// 获取p1向下和p2向左的交点
			Point linkPoint1 = getWrapPoint(point1DownChanel, point2LeftChanel);
			// 获取p1向右和p2向下的交点
			Point linkPoint2 = getWrapPoint(point1RightChanel, point2UpChanel);
			return (linkPoint1 == null) ? linkPoint2 : linkPoint1;
		}
		return null;
	}

	/**
	 * 遍历两个通道, 获取它们的交点
	 * 
	 * @param p1Chanel 第一个点的通道
	 * @param p2Chanel 第二个点的通道
	 * @return 两个通道有交点，返回交点，否则返回null
	 */
	private Point getWrapPoint(List<Point> p1Chanel, List<Point> p2Chanel)
	{
		for (int i = 0; i < p1Chanel.size(); i++)
		{
			Point temp1 = p1Chanel.get(i);
			for (int j = 0; j < p2Chanel.size(); j++)
			{
				Point temp2 = p2Chanel.get(j);
				if (temp1.equals(temp2))
				{
					// 如果两个List中有元素有同一个, 表明这两个通道有交点
					return temp1;
				}
			}
		}
		return null;
	}

	/**
	 * 判断两个y座标相同的点对象之间是否有障碍, 以p1为中心向右遍历
	 * 
	 * @param p1
	 * @param p2
	 * @param pieceWidth
	 * @return 两个Piece之间有障碍返回true，否则返回false
	 */
	private boolean isXBlock(Point p1, Point p2, int pieceWidth)
	{
		if (p2.x < p1.x)
		{
			// 如果p2在p1左边, 调换参数位置调用本方法
			return isXBlock(p2, p1, pieceWidth);
		}
		for (int i = p1.x + pieceWidth; i < p2.x; i = i + pieceWidth)
		{
			if (hasPiece(i, p1.y))
			{// 有障碍
				return true;
			}
		}
		return false;
	}

	/**
	 * 判断两个x座标相同的点对象之间是否有障碍, 以p1为中心向下遍历
	 * 
	 * @param p1
	 * @param p2
	 * @param pieceHeight
	 * @return 两个Piece之间有障碍返回true，否则返回false
	 */
	private boolean isYBlock(Point p1, Point p2, int pieceHeight)
	{
		if (p2.y < p1.y)
		{
			// 如果p2在p1的上面, 调换参数位置重新调用本方法
			return isYBlock(p2, p1, pieceHeight);
		}
		for (int i = p1.y + pieceHeight; i < p2.y; i = i + pieceHeight)
		{
			if (hasPiece(p1.x, i))
			{
				// 有障碍
				return true;
			}
		}
		return false;
	}

	/**
	 * 判断GamePanel中的x, y座标中是否有Piece对象
	 * 
	 * @param x
	 * @param y
	 * @return true 表示有该座标有piece对象 false 表示没有
	 */
	private boolean hasPiece(int x, int y)
	{
		if (findPiece(x, y) == null)
			return false;
		return true;
	}

	/**
	 * 给一个Point对象,返回它的左边通道
	 * 
	 * @param p
	 * @param pieceWidth piece图片的宽
	 * @param min 向左遍历时最小的界限
	 * @return 给定Point左边的通道
	 */
	private List<Point> getLeftChanel(Point p, int min, int pieceWidth)
	{
		List<Point> result = new ArrayList<Point>();
		// 获取向左通道, 由一个点向左遍历, 步长为Piece图片的宽
		for (int i = p.x - pieceWidth; i >= min
			; i = i - pieceWidth)
		{
			// 遇到障碍, 表示通道已经到尽头, 直接返回
			if (hasPiece(i, p.y))
			{
				return result;
			}
			result.add(new Point(i, p.y));
		}
		return result;
	}
	
	/**
	 * 给一个Point对象, 返回它的右边通道
	 * 
	 * @param p
	 * @param pieceWidth
	 * @param max 向右时的最右界限
	 * @return 给定Point右边的通道
	 */
	private List<Point> getRightChanel(Point p, int max, int pieceWidth)
	{
		List<Point> result = new ArrayList<Point>();
		// 获取向右通道, 由一个点向右遍历, 步长为Piece图片的宽
		for (int i = p.x + pieceWidth; i <= max
			; i = i + pieceWidth)
		{
			// 遇到障碍, 表示通道已经到尽头, 直接返回
			if (hasPiece(i, p.y))
			{
				return result;
			}
			result.add(new Point(i, p.y));
		}
		return result;
	}
	
	/**
	 * 给一个Point对象, 返回它的上面通道
	 * 
	 * @param p
	 * @param min 向上遍历时最小的界限
	 * @param pieceHeight
	 * @return 给定Point上面的通道
	 */
	private List<Point> getUpChanel(Point p, int min, int pieceHeight)
	{
		List<Point> result = new ArrayList<Point>();
		// 获取向上通道, 由一个点向右遍历, 步长为Piece图片的高
		for (int i = p.y - pieceHeight; i >= min
			; i = i - pieceHeight)
		{
			// 遇到障碍, 表示通道已经到尽头, 直接返回
			if (hasPiece(p.x, i))
			{
				// 如果遇到障碍, 直接返回
				return result;
			}
			result.add(new Point(p.x, i));
		}
		return result;
	}
	
	/**
	 * 给一个Point对象, 返回它的下面通道
	 * 
	 * @param p
	 * @param max 向上遍历时的最大界限
	 * @return 给定Point下面的通道
	 */
	private List<Point> getDownChanel(Point p, int max, int pieceHeight)
	{
		List<Point> result = new ArrayList<Point>();
		// 获取向下通道, 由一个点向右遍历, 步长为Piece图片的高
		for (int i = p.y + pieceHeight; i <= max
			; i = i + pieceHeight)
		{
			// 遇到障碍, 表示通道已经到尽头, 直接返回
			if (hasPiece(p.x, i))
			{
				// 如果遇到障碍, 直接返回
				return result;
			}
			result.add(new Point(p.x, i));
		}
		return result;
	}
}

第五块：实现Activity

这一块相对比较简单，显示之前定义好的布局文件，为按钮注册监听器，对触碰事件的处理，游戏胜利的处理，游戏失败的处理等。

Activity用到前面定义的所有类和方法

这里还有一个工具类：GameConf.java, 负责管理游戏初始化的设置信息

package org.wwj.link.object;

import android.content.Context;
//负责管理游戏的初始化设置信息的工具类
public class GameConf
{
	// 设置连连看的每个方块的图片的宽、高
	public static final int PIECE_WIDTH = 40;
	public static final int PIECE_HEIGHT = 40;
	// 记录游戏的总事件（100秒）.
	public static int DEFAULT_TIME = 100;	
	// Piece[][]数组第一维的长度
	private int xSize;
	// Piece[][]数组第二维的长度
	private int ySize;
	// Board中第一张图片出现的x座标
	private int beginImageX;
	// Board中第一张图片出现的y座标
	private int beginImageY;
	// 记录游戏的总时间, 单位是秒
	private long gameTime;
	private Context context;

	/**
	 * 提供一个参数构造器
	 * 
	 * @param xSize Piece[][]数组第一维长度
	 * @param ySize Piece[][]数组第二维长度
	 * @param beginImageX Board中第一张图片出现的x座标
	 * @param beginImageY Board中第一张图片出现的y座标
	 * @param gameTime 设置每局的时间, 单位是秒
	 * @param context 应用上下文
	 */
	public GameConf(int xSize, int ySize, int beginImageX,
		int beginImageY, long gameTime, Context context)
	{
		this.xSize = xSize;
		this.ySize = ySize;
		this.beginImageX = beginImageX;
		this.beginImageY = beginImageY;
		this.gameTime = gameTime;
		this.context = context;
	}

	public long getGameTime()
	{
		return gameTime;
	}

	public int getXSize()
	{
		return xSize;
	}

	public int getYSize()
	{
		return ySize;
	}

	public int getBeginImageX()
	{
		return beginImageX;
	}

	public int getBeginImageY()
	{
		return beginImageY;
	}

	public Context getContext()
	{
		return context;
	}
}

Activity文件

这个游戏只需要用到一个Activity，所以相对而言比较简单，不存在信息之间的传递。

==>>Link.java

ackage org.wwj.link.Activity;

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

import org.wwj.link.board.GameService;
import org.wwj.link.board.impl.GameServiceImpl;
import org.wwj.link.object.GameConf;
import org.wwj.link.object.LinkInfo;
import org.wwj.link.view.GameView;
import org.wwj.link.view.Piece;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.Vibrator;
import android.view.MotionEvent;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;


public class Link extends Activity
{
	// 游戏配置对象
	private GameConf config;
	// 游戏业务逻辑接口
	private GameService gameService;
	// 游戏界面
	private GameView gameView;
	// 开始按钮
	private Button startButton;
	// 记录剩余时间的TextView
	private TextView timeTextView;
	// 失败后弹出的对话框
	private AlertDialog.Builder lostDialog;
	// 游戏胜利后的对话框
	private AlertDialog.Builder successDialog;
	// 定时器
	private Timer timer = new Timer();
	// 记录游戏的剩余时间
	private int gameTime;
	// 记录是否处于游戏状态
	private boolean isPlaying;
	// 振动处理类
	private Vibrator vibrator;
	// 记录已经选中的方块
	private Piece selected = null;
	private Handler handler = new Handler()
	{
		public void handleMessage(Message msg)
		{
			switch (msg.what)
			{
				case 0x123:
					timeTextView.setText("剩余时间： " + gameTime);
					gameTime--;
					// 时间小于0, 游戏失败
					if (gameTime < 0)
					{
						stopTimer();
						// 更改游戏的状态
						isPlaying = false;
						lostDialog.show();
						return;
					}
					break;
			}
		}
	};

	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		// 初始化界面
		init();
	}

	// 初始化游戏的方法
	private void init()
	{	
		//初始化游戏配置信息xSize,ySize,beginImageX,beginImgaeY,gameTime,context
		config = new GameConf(8, 9, 2, 10 , 100000, this);
		// 得到游戏区域对象
		gameView = (GameView) findViewById(R.id.gameView);
		// 获取显示剩余时间的文本框
		timeTextView = (TextView) findViewById(R.id.timeText);
		// 获取开始按钮
		startButton = (Button) this.findViewById(R.id.startButton);
		// 获取振动器
		vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);
		gameService = new GameServiceImpl(this.config);
		gameView.setGameService(gameService);
		// 为开始按钮的单击事件绑定事件监听器
		startButton.setOnClickListener(new View.OnClickListener()
		{
			public void onClick(View source)
			{
				startGame(GameConf.DEFAULT_TIME);
			}
		});
		// 为游戏区域的触碰事件绑定监听器
		this.gameView.setOnTouchListener(new View.OnTouchListener()
		{
			public boolean onTouch(View view, MotionEvent e)
			{
				if (e.getAction() == MotionEvent.ACTION_DOWN)
				{
					gameViewTouchDown(e);
				}
				if (e.getAction() == MotionEvent.ACTION_UP)
				{
					gameViewTouchUp(e);
				}
				return true;
			}
		});
		// 初始化游戏失败的对话框
		lostDialog = createDialog("Lost", "游戏失败！ 重新开始", R.drawable.lost)
			.setPositiveButton("确定", new DialogInterface.OnClickListener()
			{
				public void onClick(DialogInterface dialog, int which)
				{
					startGame(GameConf.DEFAULT_TIME);
				}
			});
		// 初始化游戏胜利的对话框
		successDialog = createDialog("Success", "游戏胜利！ 重新开始",
			R.drawable.success).setPositiveButton("确定",
			new DialogInterface.OnClickListener()
			{
				public void onClick(DialogInterface dialog, int which)
				{
					startGame(GameConf.DEFAULT_TIME);
				}
			});
	}
	@Override
	protected void onPause()
	{
		// 暂停游戏
		stopTimer();
		super.onPause();
	}
	@Override
	protected void onResume()
	{
		// 如果处于游戏状态中
		if (isPlaying)
		{
			// 以剩余时间重写开始游戏
			startGame(gameTime);
		}
		super.onResume();
	}

	// 触碰游戏区域的处理方法
	private void gameViewTouchDown(MotionEvent event)
	{
		// 获取GameServiceImpl中的Piece[][]数组
		Piece[][] pieces = gameService.getPieces();
		// 获取用户点击的x座标
		float touchX = event.getX();
		// 获取用户点击的y座标
		float touchY = event.getY();
		// 根据用户触碰的座标得到对应的Piece对象
		Piece currentPiece = gameService.findPiece(touchX, touchY);
		// 如果没有选中任何Piece对象(即鼠标点击的地方没有图片), 不再往下执行
		if (currentPiece == null)
			return;
		// 将gameView中的选中方块设为当前方块
		this.gameView.setSelectedPiece(currentPiece);
		// 表示之前没有选中任何一个Piece
		if (this.selected == null)
		{
			// 将当前方块设为已选中的方块, 重新将GamePanel绘制, 并不再往下执行
			this.selected = currentPiece;
			this.gameView.postInvalidate();
			return;
		}
		// 表示之前已经选择了一个
		if (this.selected != null)
		{
			// 在这里就要对currentPiece和prePiece进行判断并进行连接
			LinkInfo linkInfo = this.gameService.link(this.selected,
				currentPiece);
			// 两个Piece不可连, linkInfo为null
			if (linkInfo == null)
			{
				// 如果连接不成功, 将当前方块设为选中方块
				this.selected = currentPiece;
				this.gameView.postInvalidate();
			}
			else
			{
				// 处理成功连接
				handleSuccessLink(linkInfo, this.selected
					, currentPiece, pieces);
			}
		}
	}
	// 触碰游戏区域的处理方法
	private void gameViewTouchUp(MotionEvent e)
	{
		this.gameView.postInvalidate();
	}
	
	// 以gameTime作为剩余时间开始或恢复游戏
	private void startGame(int gameTime)
	{
		// 如果之前的timer还未取消，取消timer
		if (this.timer != null)
		{
			stopTimer();
		}
		// 重新设置游戏时间
		this.gameTime = gameTime;		
		// 如果游戏剩余时间与总游戏时间相等，即为重新开始新游戏
		if(gameTime == GameConf.DEFAULT_TIME)
		{
			// 开始新的游戏游戏
			gameView.startGame();
		}
		isPlaying = true;	
		this.timer = new Timer();
		// 启动计时器 ， 每隔1秒发送一次消息
		this.timer.schedule(new TimerTask()
		{
			public void run()
			{
				handler.sendEmptyMessage(0x123);
			}
		}, 0, 1000);
		// 将选中方块设为null。
		this.selected = null;
	}	

	/**
	 * 成功连接后处理
	 * 
	 * @param linkInfo 连接信息
	 * @param prePiece 前一个选中方块
	 * @param currentPiece 当前选择方块
	 * @param pieces 系统中还剩的全部方块
	 */
	private void handleSuccessLink(LinkInfo linkInfo, Piece prePiece,
		Piece currentPiece, Piece[][] pieces)
	{
		// 它们可以相连, 让GamePanel处理LinkInfo
		this.gameView.setLinkInfo(linkInfo);
		// 将gameView中的选中方块设为null
		this.gameView.setSelectedPiece(null);
		this.gameView.postInvalidate();
		// 将两个Piece对象从数组中删除
		pieces[prePiece.getIndexX()][prePiece.getIndexY()] = null;
		pieces[currentPiece.getIndexX()][currentPiece.getIndexY()] = null;
		// 将选中的方块设置null。
		this.selected = null;
		// 手机振动(100毫秒)
		this.vibrator.vibrate(100);
		// 判断是否还有剩下的方块, 如果没有, 游戏胜利
		if (!this.gameService.hasPieces())
		{
			// 游戏胜利
			this.successDialog.show();
			// 停止定时器
			stopTimer();
			// 更改游戏状态
			isPlaying = false;
		}
	}

	// 创建对话框的工具方法
	private AlertDialog.Builder createDialog(String title, String message,
		int imageResource)
	{
		return new AlertDialog.Builder(this).setTitle(title)
			.setMessage(message).setIcon(imageResource);
	}
	private void stopTimer()
	{
		// 停止定时器
		this.timer.cancel();
		this.timer = null;
	}
}

以上所有内容就是开发一个简单的连连看的过程和代码，这是本人初学这个游戏开发的一些总结，有很多内容都理解不够透彻，还有待加强整个游戏的逻辑分析能力。不过这只是开始，学习Android的时间也不算长，Java的知识也还只是处于初级阶段，我相信，经过长时间的沉淀，我的开发能力一定会变得更强的。这个连连看游戏，当做一次项目的练习，我会试着去开发属于自己的东西，不断加强自己的开发能力，增加项目经验，学习知识是一个漫长的过程，需要有足够的耐心去面对学习过程所遇到的麻烦和挫折，一个多月的学习以来，我深切感受了这一点，不过我会鼓足勇气继续迎接下一场挑战，wwj，未完待续。