在上一篇《我的Android进阶之旅------>Android疯狂连连看游戏的实现之加载界面图片和实现游戏Activity(四)》中提到的两个类：
GameConf:负责管理游戏的初始化设置信息。
GameService：负责游戏的逻辑实现。
其中GameConf的代码如下：cn\oyp\link\utils\GameConf.java
package cn.oyp.link.utils; import androID.content.Context; /** * 保存游戏配置的对象 <br/> * <br/> * 关于本代码介绍可以参考一下博客: 欧阳鹏的CSDN博客</a> <br/> */ public class GameConf { /** * 连连看的每个方块的图片的宽 */ public static final int PIECE_WIDTH = 40; /** * 连连看的每个方块的图片的高s */ 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; } /** * @return 游戏的总时间 */ public long getGameTime() { return gameTime; } /** * @return PIEce[][]数组第一维的长度 */ public int getXSize() { return xSize; } /** * @return PIEce[][]数组第二维的长度 */ public int getYSize() { return ySize; } /** * @return Board中第一张图片出现的x座标 */ public int getBeginImageX() { return beginImageX; } /** * @return Board中第一张图片出现的y座标 */ public int getBeginImageY() { return beginImageY; } /** * @return 应用上下文 */ public Context getContext() { return context; } } 而GameService则是整个游戏逻辑实现的核心，而且GameService是一个可以复用的业务逻辑类，它于游戏平台无关，既可以在Java Swing中使用，也可以在AndroID游戏中使用，甚至只要稍作修改，GameService也可以移植到C#平台的连连看游戏中。
考虑到程序的可扩展行，先给GameService组件定义一个接口，代码如下：cn\oyp\link\board\GameService.java
package cn.oyp.link.board; import cn.oyp.link.utils.linkInfo; import cn.oyp.link.vIEw.PIEce; /** * 游戏逻辑接口 <br/> * <br/> * 关于本代码介绍可以参考一下博客: 欧阳鹏的CSDN博客</a> <br/> */ public interface GameService { /** * 控制游戏开始的方法 */ public voID start(); /** * 定义一个接口方法,用于返回一个二维数组 * * @return 存放方块对象的二维数组 */ public PIEce[][] getPIEces(); /** * 判断参数PIEce[][]数组中是否还存在非空的PIEce对象 * * @return 如果还剩PIEce对象返回true,没有返回false */ public boolean hasPIEces(); /** * 根据鼠标的x座标和y座标,查找出一个PIEce对象 * * @param touchX * 鼠标点击的x座标 * @param touchY * 鼠标点击的y座标 * @return 返回对应的PIEce对象,没有返回null */ public PIEce findPIEce(float touchX,float touchY); /** * 判断两个PIEce是否可以相连,可以连接,返回linkInfo对象 * * @param p1 * 第一个PIEce对象 * @param p2 * 第二个PIEce对象 * @return 如果可以相连，返回linkInfo对象,如果两个PIEce不可以连接,返回null */ public linkInfo link(PIEce p1,PIEce p2); } 下面来具体实现GameService组件，首先的public voID start()方法，public PIEce[][] getPIEces()方法和public boolean hasPIEces()方法很容易实现，具体实现如下：cn\oyp\link\board\impl\GameServiceImpl.java
/** * 游戏逻辑的实现类 <br/> * <br/> * 关于本代码介绍可以参考一下博客: 欧阳鹏的CSDN博客</a> <br/> */ public class GameServiceImpl implements GameService { /** * 定义一个PIEce[][]数组 */ private PIEce[][] pIEces; /** * 游戏配置对象 */ private GameConf config; /** * 构造方法 * * @param config * 游戏配置对象 */ public GameServiceImpl(GameConf config) { // 将游戏的配置对象设置本类中 this.config = config; } @OverrIDe 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); } @OverrIDe public PIEce[][] getPIEces() { return this.pIEces; } @OverrIDe 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; } ... } 1、获取触碰点的方块
首先当用户碰触游戏界面时，事件监听器获取的是该触碰到在游戏界面上的X、Y坐标，但是程序需要的是获取用户碰触的到底是那个方块，因此程序必须把界面上的X、Y坐标换算成在PIEce[][]二维数组中的两个索引值。考虑到游戏界面上每个方块的高度和宽度都是相同的，因此想要将界面上的X、Y坐标换算成PIEce[][]二维数组中的索引也比较简单，只要拿X、Y坐标值除以图片的宽、高即可。下面是根据触点X、Y坐标获取对于方块的代码：
/** * 根据触碰点的位置查找相应的方块 */ @OverrIDe 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[][]数组中的第一维的索引值 ，第二个参数为每张图片的宽 */ int indexX = getIndex(relativeX,GameConf.PIECE_WIDTH); /* * 获取relativeY座标在PIEce[][]数组中的第二维的索引值 ，第二个参数为每张图片的高 */ 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]; } 上面的方法调用了getIndex(int relative,int size)方法，该方法的实现就是拿relative除以size,程序需要判断可以整除和不能整除两种情况：如果可以整除，说明还在前一个方块内；如果不能整除，则对于于下一个方块，下面是getIndex(int relative,int size)方法的代码：
/** * 工具方法：计算相对于PIEce[][]数组的第一维 或第二维的索引值 * * @param relative * 座标 * @param size * 每张图片边的长或者宽 * @return */ private int getIndex(int relative,int size) { // 表示座标relative不在该数组中，数组下标从0开始 int index = -1; /* * 让座标除以边长,没有余数,索引减1， 例如点了x座标为20,边宽为10,20 % 10 没有余数,index为1,* 即在数组中的索引为1(第二个元素) */ if (relative % size == 0) { index = relative / size - 1; } else { /* * 有余数,例如点了x座标为21,21 % 10有余数,index为2， 即在数组中的索引为2(第三个元素) */ index = relative / size; } return index; } 2、判断两个方块是否可以相连
两个方块可以相连的情况可以大致分为以下几种：
下面的link(PIEce p1,PIEce p2)方法把这四种情况分开进行处理，代码如下：
@OverrIDe 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(); // 情况1：如果两个PIEce在同一行，并且可以直接相连 if (p1.getIndexY() == p2.getIndexY()) { // 它们在同一行并可以相连 if (!isXBlock(p1Point,p2Point,GameConf.PIECE_WIDTH)) { // 它们之间没有真接障碍,没有转折点 return new linkInfo(p1Point,p2Point); } } // 情况2：如果两个PIEce在同一列，并且可以直接相连 if (p1.getIndexX() == p2.getIndexX()) { if (!isYBlock(p1Point,GameConf.PIECE_HEIGHT)) { // 它们之间没有真接障碍,p2Point); } } /* * 情况3：两个PIEce以两条线段相连，也就是有一个转折点的情况。 获取两个点的直角相连的点,即只有一个转折点 */ Point cornerPoint = getCornerPoint(p1Point,GameConf.PIECE_WIDTH,GameConf.PIECE_HEIGHT); // 它们之间有一个转折点 if (cornerPoint != null) { return new linkInfo(p1Point,cornerPoint,p2Point); } /* * 情况4：两个PIEce以三条线段相连，有两个转折点的情况。 该map的key存放第一个转折点,* value存放第二个转折点,map的size()说明有多少种可以连的方式 */ Map<Point,Point> turns = getlinkPoints(p1Point,GameConf.PIECE_WIDTH); // 它们之间有转折点 if (turns.size() != 0) { // 获取p1和p2之间最短的连接信息 return getShortcut(p1Point,turns,getdistance(p1Point,p2Point)); } return null; } 3、定义获取通道的方法
所谓通道，指的是一个方块上、下、左、右四个方向上的空白方块，如下图所示：
下面是获取某个坐标点四周通道的四个方法：
/** * 给一个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) { // 遇到障碍,返回它的上面通道 * * @param p * @param min * 向上遍历时最小的界限 * @param pIEceHeight * @return 给定Point上面的通道 */ private List<Point> getUpChanel(Point p,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 pIEceHeight) { List<Point> result = new ArrayList<Point>(); // 获取向下通道,步长为PIEce图片的高 for (int i = p.y + pIEceHeight; i <= max; i = i + pIEceHeight) { // 遇到障碍,i)); } return result; } 上面调用到的hasPIEce(int x,int y)方法是判断GamePanel中的x,y座标中是否有PIEce对象的，代码如下：
/** * 判断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; } 4、没有转折点的横向连接
如果两个PIEce对象在PIEce[][]数组中的第二维索引值相等，那么这两个PIEce就在同一行，这时候需要判断两个PIEce直接是否有障碍，调用isXBlock(Point p1,Point p2,int pIEceWIDth)方法，代码如下：
/** * 判断两个y座标相同的点对象之间是否有障碍,以p1为中心向右遍历 * * @param p1 * @param p2 * @param pIEceWIDth * 连连看的每个方块的图片的宽 * @return 两个PIEce之间有障碍返回true，否则返回false */ private boolean isXBlock(Point p1,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; } 如果两个方块位于同一行，且它们之间没有障碍，那么这两个方块就可以消除，两个方块的连接信息就是它们的中心。
5、没有转折点的纵向连接
如果两个PIEce对象在PIEce[][]数组中的第一维索引值相等，那么这两个PIEce就在同一列，这时候需要判断两个PIEce直接是否有障碍，调用isYBlock(Point p1,int pIEceWIDth)方法，代码如下：
/** * 判断两个x座标相同的点对象之间是否有障碍,以p1为中心向下遍历 * * @param p1 * @param p2 * @param pIEceHeight * 连连看的每个方块的图片的高 * @return 两个PIEce之间有障碍返回true，否则返回false */ private boolean isYBlock(Point p1,int pIEceHeight) { if (p2.y < p1.y) { // 如果p2在p1的上面,调换参数位置重新调用本方法 return isYBlock(p2,pIEceHeight); } for (int i = p1.y + pIEceHeight; i < p2.y; i = i + pIEceHeight) { if (hasPIEce(p1.x,i)) { // 有障碍 return true; } } return false; } 如果两个方块位于同一列，且它们之间没有障碍，那么这两个方块就可以消除，两个方块的连接信息就是它们的中心。
6、一个转折点的连接
对于两个方块连接线上只有一个转折点的情况，程序需要先找到这个转折点。为了找到这个转折点，程序定义了一个遍历两个通道并获取它们交点的方法，getWrapPoint(List<Point> p1Chanel,List<Point> p2Chanel)，代码如下：
/** * 遍历两个通道,获取它们的交点 * * @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; } 为了找出两个方块连接线上的连接点，程序需要分析p1和p2的位置分布。所以我们可以分析p2要么在p1的右上角，要么在p1的右下角。至于p2位于p1的左上角和左下角的情况，只要将p1、p2交换即可，如下图所示：
当p2位于p1右上角时候，应该计算p1的右通道和p2的下通道是否有交点，p1的上通道和p2的左通道是否有交点。
当p2位于p1右下角时候，应该计算p1的右通道和p2的上通道是否有交点，p1的下通道和p2的左通道是否有交点。
下面是具体是实现方法getCornerPoint(Point point1,Point point2,int pIEceWIDth,
int pIEceHeight)的代码：
/** * 获取两个不在同一行或者同一列的座标点的直角连接点,即只有一个转折点 * * @param point1 * 第一个点 * @param point2 * 第二个点 * @return 两个不在同一行或者同一列的座标点的直角连接点 */ private Point getCornerPoint(Point point1,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); // 获取p1向上的通道 List<Point> point1UpChanel = getUpChanel(point1,point2.y,pIEceHeight); // 获取p1向下的通道 List<Point> point1DownChanel = getDownChanel(point1,pIEceHeight); // 获取p2向下的通道 List<Point> point2DownChanel = getDownChanel(point2,point1.y,pIEceHeight); // 获取p2向左的通道 List<Point> point2leftChanel = getleftChanel(point2,point1.x,pIEceWIDth); // 获取p2向上的通道 List<Point> point2UpChanel = getUpChanel(point2,pIEceHeight); // 如果point2在point1的右上角 if (isRightUp(point1,point2)) { // 获取p1向右和p2向下的交点 Point linkPoint1 = getWrapPoint(point1RightChanel,point2DownChanel); // 获取p1向上和p2向左的交点 Point linkPoint2 = getWrapPoint(point1UpChanel,point2leftChanel); // 返回其中一个交点,如果没有交点,则返回null return (linkPoint1 == null) ? linkPoint2 : linkPoint1; } /**********************************************************/ // 如果point2在point1的右下角 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; } 上面方法调用了以下四个方法：
/** * 判断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); } 7、两个转折点的连接
两个转折点可以分为以下几种情况讨论：
至于p2位于p1的左上角和左下角的情况，只要将p1、p2交换即可。
1）、p1、p2位于同一行，不能直接相连，就必须有两个转折点，如下图所示
当p1与p2位于同一行不能直接相连，这两个点既可以在上面相连，也可以在下面相连，这两种情况都代表他们可以相连，先把这两种情况加入到结果中，最后去计算最近的距离。
实现时先构建一个Map,Map的key为第一个转折点，Map的value为第二个转折点，如果Map的size()大于1，说明这两个Point有多种连接途径，那么程序还需要计算路径最小的连接方式。
2）p1、p2位于同一行，不能直接相连，就必须有两个转折点，如上图所示。
当p1与p2位于同一列不能直接相连，这两个点既可以在左边相连，也可以在右边相连，这两种情况都代表他们可以相连，先把这两种情况加入到结果中，最后去计算最近的距离。
实现时先构建一个Map,Map的key为第一个转折点，Map的value为第二个转折点，如果Map的size()大于1，说明这两个Point有多种连接途径，那么程序还需要计算路径最小的连接方式。
3)p2位于p1右下角的六种转折情况，如下图所示：
定义一个方法来处理上面具有两个连接点的情况，getlinkPoints(Point point1,
int pIEceWIDth,int pIEceHeight)，代码如下所示：
/** * 获取两个转折点的情况 * * @param point1 * @param point2 * @return Map对象的每个key-value对代表一种连接方式， 其中key、value分别代表第1个、第2个连接点 */ private Map<Point,Point> getlinkPoints(Point point1,int pIEceHeight) { Map<Point,Point> result = new HashMap<Point,Point>(); // 获取以point1为中心的向上的通道 List<Point> p1UpChanel = getUpChanel(point1,pIEceHeight); // 获取以point1为中心的向右的通道 List<Point> p1RightChanel = getRightChanel(point1,pIEceWIDth); // 获取以point1为中心的向下的通道 List<Point> p1DownChanel = getDownChanel(point1,pIEceHeight); // 获取以point2为中心的向下的通道 List<Point> p2DownChanel = getDownChanel(point2,pIEceHeight); // 获取以point2为中心的向左的通道 List<Point> p2leftChanel = getleftChanel(point2,pIEceWIDth); // 获取以point2为中心的向上的通道 List<Point> p2UpChanel = getUpChanel(point2,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,调用本方法 return getlinkPoints(point2,pIEceHeight); } // 情况1：如果p1、p2位于同一行而不能直接相连，需要两个转折点，可以在上面相连也可以在下面相连 if (point1.y == point2.y) {// 在同一行 // 第1步: 向上遍历 // 以p1的中心点向上遍历获取点集合 p1UpChanel = getUpChanel(point1,pIEceHeight); // 以p2的中心点向上遍历获取点集合 p2UpChanel = getUpChanel(point2,pIEceHeight); // 如果两个集合向上中有Y坐标相同，即在同一行，且之间没有障碍物 Map<Point,Point> uplinkPoints = getXlinkPoints(p1UpChanel,p2UpChanel,pIEceHeight); // 第2步: 向下遍历,不超过Board(有方块的地方)的边框 // 以p1中心点向下遍历获取点集合 p1DownChanel = getDownChanel(point1,heightmax,pIEceHeight); // 以p2中心点向下遍历获取点集合 p2DownChanel = getDownChanel(point2,Point> downlinkPoints = getXlinkPoints(p1DownChanel,p2DownChanel,pIEceHeight); result.putAll(uplinkPoints); result.putAll(downlinkPoints); } // 情况2：p1、p2位于同一列不能直接相连，需要两个转折点，可以在左边相连也可以在右边相连 if (point1.x == point2.x) {// 在同一列 // 第1步:向左遍历 // 以p1的中心点向左遍历获取点集合 List<Point> p1leftChanel = getleftChanel(point1,pIEceWIDth); // 以p2的中心点向左遍历获取点集合 p2leftChanel = getleftChanel(point2,pIEceWIDth); // 如果两个集合向上中有X坐标相同，即在同一列，且之间没有障碍物 Map<Point,Point> leftlinkPoints = getYlinkPoints(p1leftChanel,p2leftChanel,pIEceWIDth); // 第2步:向右遍历,不得超过Board的边框（有方块的地方） // 以p1的中心点向右遍历获取点集合 p1RightChanel = getRightChanel(point1,wIDthMax,pIEceWIDth); // 以p2的中心点向右遍历获取点集合 List<Point> p2RightChanel = getRightChanel(point2,Point> rightlinkPoints = getYlinkPoints(p1RightChanel,p2RightChanel,pIEceWIDth); result.putAll(leftlinkPoints); result.putAll(rightlinkPoints); } // 情况3:point2位于point1的右上角,分六种情况讨论 if (isRightUp(point1,point2)) { //第1步： 获取point1向上遍历,point2向下遍历时横向可以连接的点 Map<Point,Point> updownlinkPoints = getXlinkPoints(p1UpChanel,pIEceWIDth); /**********************************************************/ //第2步：获取point1向右遍历,point2向左遍历时纵向可以连接的点 Map<Point,Point> rightleftlinkPoints = getYlinkPoints( p1RightChanel,pIEceHeight); /**********************************************************/ // 获取以p1为中心的向上通道 p1UpChanel = getUpChanel(point1,pIEceHeight); // 获取以p2为中心的向上通道 p2UpChanel = getUpChanel(point2,pIEceHeight); //第3步： 获取point1向上遍历,point2向上遍历时横向可以连接的点 Map<Point,Point> upUplinkPoints = getXlinkPoints(p1UpChanel,pIEceWIDth); /**********************************************************/ // 获取以p1为中心的向下通道 p1DownChanel = getDownChanel(point1,pIEceHeight); // 获取以p2为中心的向下通道 p2DownChanel = getDownChanel(point2,pIEceHeight); //第4步： 获取point1向下遍历,Point> downDownlinkPoints = getXlinkPoints(p1DownChanel,pIEceWIDth); /**********************************************************/ // 获取以p1为中心的向右通道 p1RightChanel = getRightChanel(point1,pIEceWIDth); // 获取以p2为中心的向右通道 List<Point> p2RightChanel = getRightChanel(point2,pIEceWIDth); //第5步：获取point1向右遍历,point2向右遍历时纵向可以连接的点 Map<Point,Point> rightRightlinkPoints = getYlinkPoints( p1RightChanel,pIEceHeight); /**********************************************************/ // 获取以p1为中心的向左通道 List<Point> p1leftChanel = getleftChanel(point1,pIEceWIDth); // 获取以p2为中心的向左通道 p2leftChanel = getleftChanel(point2,pIEceWIDth); //第6步： 获取point1向左遍历,Point> leftleftlinkPoints = getYlinkPoints(p1leftChanel,pIEceHeight); /**********************************************************/ result.putAll(updownlinkPoints); result.putAll(rightleftlinkPoints); result.putAll(upUplinkPoints); result.putAll(downDownlinkPoints); result.putAll(rightRightlinkPoints); result.putAll(leftleftlinkPoints); } // 情况4：point2位于point1的右下角,分六种情况讨论 if (isRightDown(point1,point2)) { //第1步： 获取point1向下遍历,point2向上遍历时横向可连接的点 Map<Point,Point> downUplinkPoints = getXlinkPoints(p1DownChanel,pIEceWIDth); /**********************************************************/ //第2步： 获取point1向右遍历,point2向左遍历时纵向可连接的点 Map<Point,point2向下遍历时横向可连接的点 Map<Point,pIEceWIDth); /**********************************************************/ // 获取以p1为中心的向左通道 List<Point> p1leftChanel = getleftChanel(point1,pIEceWIDth); //第5步： 获取point1向左遍历,pIEceHeight); /**********************************************************/ // 获取以p1为中心的向右通道 p1RightChanel = getRightChanel(point1,pIEceWIDth); //第6步： 获取point1向右遍历,pIEceHeight); /**********************************************************/ result.putAll(downUplinkPoints); result.putAll(rightleftlinkPoints); result.putAll(upUplinkPoints); result.putAll(downDownlinkPoints); result.putAll(leftleftlinkPoints); result.putAll(rightRightlinkPoints); } return result; } 上面调用的getXlinkPoints、getYlinkPoints方法代码如下：
/** * 遍历两个集合,先判断第一个集合的元素的x座标与另一个集合中的元素x座标相同(纵向),如果相同,即在同一列,再判断是否有障碍,* 没有则加到结果的Map中去 * * @param p1Chanel * @param p2Chanel * @param pIEceHeight * @return */ private Map<Point,Point> getYlinkPoints(List<Point> p1Chanel,List<Point> p2Chanel,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,int pIEceWIDth) { Map<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,pIEceWIDth)) { // 没有障碍则直接加到结果的map中 result.put(temp1,temp2); } } } } return result; } 8、找出最短距离
为了找出所有连接情况中的最短路径，程序可以分为以下2步骤来实现：
遍历转折点Map中的所有key-value对，与原来选择的两个点构成一个linkInfo。每个linkInfo代表一条完整的连接路径，并将这些linkInfo搜集成一个List集合。
遍历第一步得到的List<linkInfo>集合，计算每个linkInfo中连接全部连接点的总距离，选与最短距离相差最小的linkInfo返回。
/** * 获取p1和p2之间最短的连接信息 * * @param p1 * @param p2 * @param turns * 放转折点的map * @param shortdistance * 两点之间的最短距离 * @return p1和p2之间最短的连接信息 */ private linkInfo getShortcut(Point p1,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,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; } 关于具体的实现步骤，请参考下面的链接：
我的Android进阶之旅------>Android疯狂连连看游戏的实现之游戏效果预览(一)
我的Android进阶之旅------>Android疯狂连连看游戏的实现之开发游戏界面(二)
我的Android进阶之旅------>Android疯狂连连看游戏的实现之状态数据模型(三)
我的Android进阶之旅------>Android疯狂连连看游戏的实现之加载界面图片和实现游戏Activity(四)
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持编程小技巧。
总结以上是内存溢出为你收集整理的Android实现疯狂连连看游戏之实现游戏逻辑(五)全部内容，希望文章能够帮你解决Android实现疯狂连连看游戏之实现游戏逻辑(五)所遇到的程序开发问题。
如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）