在上一篇《我的Android進階之旅------>Android瘋狂連連看遊戲的實現之加載界面圖片和實現遊戲Activity(四)》中提到的兩個類:
- GameConf:負責管理遊戲的初始化設置信息。
- GameService:負責遊戲的邏輯實現。
- package cn.oyp.link.utils;
- import android.content.Context;
- /**
- * 保存遊戲配置的對象 <br/>
- * <br/>
- * 關於本代碼介紹可以參考一下博客: <a href="http://blog.csdn.net/ouyang_peng">歐陽鵬的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/>
- * 關於本代碼介紹可以參考一下博客: <a href="http://blog.csdn.net/ouyang_peng">歐陽鵬的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/>
- * 關於本代碼介紹可以參考一下博客: <a href="http://blog.csdn.net/ouyang_peng">歐陽鵬的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個拐角。
- @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;
- }
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的左通道是否有交點。
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種轉折情況。
1)、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右下角的六種轉折情況,如下圖所示:
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、找出最短距離
- 遍歷轉折點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;
- }