Android实现疯狂连连看游戏之实现游戏逻辑(五)

在上一篇《我的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, 边宽为10, 21 % 10有余数, index为2， 即在数组中的索引为2(第三个元素) 
    */ 
   index = relative / size; 
  } 
  return index; 
 } 

2、判断两个方块是否可以相连

两个方块可以相连的情况可以大致分为以下几种：

• 两个方块位于同一条水平线，可以直接相连。
• 两个方块位于同一条竖直线，可以直接相连。
• 两个方块以两条线段相连，也就是有1个拐角。
• 两个方块以三条线段相连，也就是有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, p2point, gameconf.piece_height)) { 
    // 它们之间没有真接障碍, 没有转折点 
    return new linkinfo(p1point, p2point); 
   } 
  } 
  /* 
   * 情况3：两个piece以两条线段相连，也就是有一个转折点的情况。 获取两个点的直角相连的点, 即只有一个转折点 
   */ 
  point cornerpoint = getcornerpoint(p1point, p2point, 
    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, p2point, 
    gameconf.piece_width, gameconf.piece_width); 
  // 它们之间有转折点 
  if (turns.size() != 0) { 
   // 获取p1和p2之间最短的连接信息 
   return getshortcut(p1point, p2point, 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) { 
   // 遇到障碍, 表示通道已经到尽头, 直接返回 
   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; 
 } 

上面调用到的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, 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; 
 } 

如果两个方块位于同一行，且它们之间没有障碍，那么这两个方块就可以消除，两个方块的连接信息就是它们的中心。

5、没有转折点的纵向连接

如果两个piece对象在piece[][]数组中的第一维索引值相等，那么这两个piece就在同一列，这时候需要判断两个piece直接是否有障碍，调用isyblock(point p1,point p2,int piecewidth)方法，代码如下：

/** 
  * 判断两个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; 
 } 

如果两个方块位于同一列，且它们之间没有障碍，那么这两个方块就可以消除，两个方块的连接信息就是它们的中心。

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, 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); 
  // 获取p1向上的通道 
  list<point> point1upchanel = getupchanel(point1, point2.y, pieceheight); 
  // 获取p1向下的通道 
  list<point> point1downchanel = getdownchanel(point1, point2.y, 
    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, point1.y, 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、两个转折点的连接

两个转折点可以分为以下几种情况讨论：

• p1、p2位于同一行，不能直接相连，就必须有两个转折点，分向上和向下两种连接情况。
• p1、p2位于同一行，不能直接相连，就必须有两个转折点，分向左和向右两种连接情况。
• p2在p1的右下角，有6中转折情况。
• p2在p1的右上角，也有6种转折情况。
  

至于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, point point2,
int piecewidth, int pieceheight)，代码如下所示：

/** 
  * 获取两个转折点的情况 
  * 
  * @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); 
  // 获取以point1为中心的向右的通道 
  list<point> p1rightchanel = getrightchanel(point1, point2.x, piecewidth); 
  // 获取以point1为中心的向下的通道 
  list<point> p1downchanel = getdownchanel(point1, point2.y, pieceheight); 
  // 获取以point2为中心的向下的通道 
  list<point> p2downchanel = getdownchanel(point2, point1.y, pieceheight); 
  // 获取以point2为中心的向左的通道 
  list<point> p2leftchanel = getleftchanel(point2, point1.x, piecewidth); 
  // 获取以point2为中心的向上的通道 
  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); 
  } 
  // 情况1：如果p1、p2位于同一行而不能直接相连，需要两个转折点，可以在上面相连也可以在下面相连 
  if (point1.y == point2.y) {// 在同一行 
   // 第1步: 向上遍历 
   // 以p1的中心点向上遍历获取点集合 
   p1upchanel = getupchanel(point1, 0, pieceheight); 
   // 以p2的中心点向上遍历获取点集合 
   p2upchanel = getupchanel(point2, 0, pieceheight); 
   // 如果两个集合向上中有y坐标相同，即在同一行，且之间没有障碍物 
   map<point, point> uplinkpoints = getxlinkpoints(p1upchanel, 
     p2upchanel, pieceheight); 
 
   // 第2步: 向下遍历, 不超过board(有方块的地方)的边框 
   // 以p1中心点向下遍历获取点集合 
   p1downchanel = getdownchanel(point1, heightmax, pieceheight); 
   // 以p2中心点向下遍历获取点集合 
   p2downchanel = getdownchanel(point2, heightmax, pieceheight); 
   // 如果两个集合向上中有y坐标相同，即在同一行，且之间没有障碍物 
   map<point, 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, 0, piecewidth); 
   // 以p2的中心点向左遍历获取点集合 
   p2leftchanel = getleftchanel(point2, 0, piecewidth); 
   // 如果两个集合向上中有x坐标相同，即在同一列，且之间没有障碍物 
   map<point, point> leftlinkpoints = getylinkpoints(p1leftchanel, 
     p2leftchanel, piecewidth); 
 
   // 第2步:向右遍历, 不得超过board的边框（有方块的地方） 
   // 以p1的中心点向右遍历获取点集合 
   p1rightchanel = getrightchanel(point1, widthmax, piecewidth); 
   // 以p2的中心点向右遍历获取点集合 
   list<point> p2rightchanel = getrightchanel(point2, widthmax, 
     piecewidth); 
   // 如果两个集合向上中有x坐标相同，即在同一列，且之间没有障碍物 
   map<point, 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, 
     p2downchanel, piecewidth); 
   /**********************************************************/ 
   //第2步：获取point1向右遍历, point2向左遍历时纵向可以连接的点 
   map<point, point> rightleftlinkpoints = getylinkpoints( 
     p1rightchanel, p2leftchanel, pieceheight); 
   /**********************************************************/ 
   // 获取以p1为中心的向上通道 
   p1upchanel = getupchanel(point1, 0, pieceheight); 
   // 获取以p2为中心的向上通道 
   p2upchanel = getupchanel(point2, 0, pieceheight); 
   //第3步： 获取point1向上遍历, point2向上遍历时横向可以连接的点 
   map<point, point> upuplinkpoints = getxlinkpoints(p1upchanel, 
     p2upchanel, piecewidth); 
   /**********************************************************/ 
   // 获取以p1为中心的向下通道 
   p1downchanel = getdownchanel(point1, heightmax, pieceheight); 
   // 获取以p2为中心的向下通道 
   p2downchanel = getdownchanel(point2, heightmax, pieceheight); 
   //第4步： 获取point1向下遍历, point2向下遍历时横向可以连接的点 
   map<point, point> downdownlinkpoints = getxlinkpoints(p1downchanel, 
     p2downchanel, piecewidth); 
   /**********************************************************/ 
   // 获取以p1为中心的向右通道 
   p1rightchanel = getrightchanel(point1, widthmax, piecewidth); 
   // 获取以p2为中心的向右通道 
   list<point> p2rightchanel = getrightchanel(point2, widthmax, 
     piecewidth); 
   //第5步：获取point1向右遍历, point2向右遍历时纵向可以连接的点 
   map<point, point> rightrightlinkpoints = getylinkpoints( 
     p1rightchanel, p2rightchanel, pieceheight); 
   /**********************************************************/ 
   // 获取以p1为中心的向左通道 
   list<point> p1leftchanel = getleftchanel(point1, 0, piecewidth); 
   // 获取以p2为中心的向左通道 
   p2leftchanel = getleftchanel(point2, 0, piecewidth); 
   //第6步： 获取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); 
  } 
  // 情况4：point2位于point1的右下角,分六种情况讨论 
  if (isrightdown(point1, point2)) { 
   //第1步： 获取point1向下遍历, point2向上遍历时横向可连接的点 
   map<point, point> downuplinkpoints = getxlinkpoints(p1downchanel, 
     p2upchanel, piecewidth); 
   /**********************************************************/ 
   //第2步： 获取point1向右遍历, point2向左遍历时纵向可连接的点 
   map<point, point> rightleftlinkpoints = getylinkpoints( 
     p1rightchanel, p2leftchanel, pieceheight); 
   /**********************************************************/ 
   // 获取以p1为中心的向上通道 
   p1upchanel = getupchanel(point1, 0, pieceheight); 
   // 获取以p2为中心的向上通道 
   p2upchanel = getupchanel(point2, 0, pieceheight); 
   //第3步： 获取point1向上遍历, point2向上遍历时横向可连接的点 
   map<point, point> upuplinkpoints = getxlinkpoints(p1upchanel, 
     p2upchanel, piecewidth); 
   /**********************************************************/ 
   // 获取以p1为中心的向下通道 
   p1downchanel = getdownchanel(point1, heightmax, pieceheight); 
   // 获取以p2为中心的向下通道 
   p2downchanel = getdownchanel(point2, heightmax, pieceheight); 
   //第4步： 获取point1向下遍历, point2向下遍历时横向可连接的点 
   map<point, point> downdownlinkpoints = getxlinkpoints(p1downchanel, 
     p2downchanel, piecewidth); 
   /**********************************************************/ 
   // 获取以p1为中心的向左通道 
   list<point> p1leftchanel = getleftchanel(point1, 0, piecewidth); 
   // 获取以p2为中心的向左通道 
   p2leftchanel = getleftchanel(point2, 0, piecewidth); 
   //第5步： 获取point1向左遍历, point2向左遍历时纵向可连接的点 
   map<point, point> leftleftlinkpoints = getylinkpoints(p1leftchanel, 
     p2leftchanel, pieceheight); 
   /**********************************************************/ 
   // 获取以p1为中心的向右通道 
   p1rightchanel = getrightchanel(point1, widthmax, piecewidth); 
   // 获取以p2为中心的向右通道 
   list<point> p2rightchanel = getrightchanel(point2, widthmax, 
     piecewidth); 
   //第6步： 获取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; 
 } 

上面调用的getxlinkpoints、getylinkpoints方法代码如下：

/** 
  * 遍历两个集合, 先判断第一个集合的元素的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; 
 } 

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, 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; 
 } 

关于具体的实现步骤，请参考下面的链接：

我的android进阶之旅------>android疯狂连连看游戏的实现之游戏效果预览(一)

我的android进阶之旅------>android疯狂连连看游戏的实现之开发游戏界面(二)

我的android进阶之旅------>android疯狂连连看游戏的实现之状态数据模型(三)

我的android进阶之旅------>android疯狂连连看游戏的实现之加载界面图片和实现游戏activity(四)

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。