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(四)

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

(0)

相关推荐

  • Android游戏源码分享之2048

    引言 程序猿们,是否还在为你的老板辛辛苦苦的打工而拿着微薄的薪水呢,还是不知道如何用自己的应用或游戏来赚钱呢! 在这里IQuick将教您如何同过自己的应用来赚取自己的第一桶金! 你是说自己的应用还没有做出来? 不,在這里已经为你提供好了一个完整的游戏应用了,在文章的下面有源码的地址哦.你只要稍做修改就可以变成一个完全属于自己的应用了,比如将4*4换成5*5,甚至是其它的.如果你实在是慵懒至极的话,你只要将本应用的包名及广告换成自己的,就可以上传到市场上轻轻松松赚取自己的第一桶金了. 如果你觉得本

  • android游戏载入的activity跳转到游戏主菜单的activity具体实现

    复制代码 代码如下: public class LoadActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); requestWindowFeature(Window.FEATURE_NO_TITLE);// 去掉标题栏 getWindow().setFlags(WindowManager.Layou

  • Android游戏开发实践之人物移动地图的平滑滚动处理

    如图所示为程序效果动画图 地图滚动的原理 在本人之前博客的文章中介绍过人物在屏幕中的移动方式,因为之前拼的游戏地图是完全填充整个手机屏幕的,所以无需处理地图的平滑滚动.这篇文章我着重的向 大家介绍一下控制人物移动后地图滚动的处理方式.举个例子 如上图所示 比如人物向右移动,如果地图贴在屏幕左边边界 将先移动人物在地图的坐标,当人物在屏幕中超过三分之二后 则将地图向人物行走的反方向移动给玩家一种人物还在向右移动的假象,其实这时候人物只是播放向右行走的动画 在屏幕中的坐标不变 ,当地图向人物行走反方

  • Android 游戏引擎libgdx 资源加载进度百分比显示案例分析

    因为案例比较简单,所以简单用AndroidApplication -> Game -> Stage 搭建框架 一.主入口,无特殊 复制代码 代码如下: public class App extends AndroidApplication { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); //初始化Demo initialize(new Demo()

  • Android五子棋游戏程序完整实例分析

    最近学习了五子棋的课程,感觉挺不错.然后自己写了个关于五子棋的android程序,从中还是能够学习到很多东西的.现在我们开始今天五子棋程序的编写历程.程序的源码请参见友情链接: 好了,我们现在开始一步步的构建出项目来,首先是如下的项目结构图: 运行的效果图: 一些前期做准备的代码 1. 主活动类MainActivity,在菜单中加入了再来一局的功能: public class MainActivity extends AppCompatActivity { private ChessBoardV

  • 解析Android游戏中获取电话状态进行游戏暂停或继续的解决方法

    对智能手机有所了解的朋友都知道其中一个应用广泛的手机操作系统Android 开源手机操作系统.那么在这一系统中想要实现通话的监听功能的话,我们应当如何操作呢?在这里就为大家详细介绍了Android监听通话的相关实现方法. 开发应用程序的时候,我们希望能够监听电话的呼入,以便执行暂停音乐播放器等操作,当电话结束之后,再次恢复播放.在Android平台可以通过TelephonyManager和PhoneStateListener来完成此任务.TelephonyManager作为一个Service接口

  • Unity3D游戏引擎实现在Android中打开WebView的实例

    本文讲述了如何在Unity中调用Android中的WebView组件,实现内部浏览器样式的页面切换.首先打开Eclipse创建一个Android的工程: UnityTestActivity.java 入口Activity ,Unity中会调用这个Activity中的方法从而打开网页. package com.xys; import android.content.Context; import android.content.Intent; import android.os.Bundle; i

  • Android开发之经典游戏贪吃蛇

    前言 这款游戏实现的思路和源码参考了Google自带的Snake的例子,其中修改了一些个人认为还不够完善的地方,加入了一些新的功能,比如屏幕上的方向操作盘,暂停按钮,开始按钮,退出按钮.另外,为了稍微增加些用户体验,除了游戏的主界面,本人自己新增了5个界面,分别是登陆界面,菜单界面,背景音乐设置界面,难度设置界面,还有个关于游戏的介绍界面.个人觉得在新手阶段,参考现成的思路和实现方式是难以避免的.重要的是我们需要有自己的理解,读懂代码之后,需要思考代码背后的实现逻辑,形成自己的思维.这样在下次开

  • Android 游戏开发之Canvas画布的介绍及方法

    Canvas,在英语中,这个单词的意思是帆布.在Android中,则把Canvas当做画布,只要我们借助设置好的画笔(Paint类)就可以在画布上绘制我们想要的任何东西:另外它也是显示位图(Bitmap类)的核心类.随用户的喜好,Canvas还可设置一些关于画布的属性,比如,画布的颜色.尺寸等.Canvas提供了如下一些方法:    Canvas(): 创建一个空的画布,可以使用setBitmap()方法来设置绘制具体的画布.    Canvas(Bitmap bitmap): 以bitmap对

  • Android游戏开发学习①弹跳小球实现方法

    本文实例讲述了Android游戏开发学习①弹跳小球实现方法.分享给大家供大家参考.具体如下: 在学习了一点点Android之后,觉得有必要记录下来,于是就开了这个新坑,慢慢来填吧. 1.运动体Movable类 本例主要模拟了一组大小不一的球以一定的水平初速度从高处落下的运动轨迹.其中的小球为一个可移动物体Movable对象,该类中除了包含小球图片对象之外,还包括了如位置坐标.水平速度.垂直速度等一系列用于模拟小球运动的成员变量和一些方法. Movable类: package com.ball;

随机推荐